Дробное преобразование Фурье: Индикатор цикла с адаптацией к скорости изменения частоты для MetaTrader 5
Содержание
- Введение
- Почему поворот, а не плотность
- Математика: чирп-сигналы, поворот и концентрация
- Две проблемы, нарушающие работу простейшей реализации индикатора FrFT
- Преобразование, унитарное по построению
- Project, Rotate и аналитический сигнал
- Поиск оптимального порядка
- От порядка к линии цикла
- Два индикатора
- Проверка
- Реальные цены для разных торговых инструментов и таймфреймов
- Пограничные случаи и возможные проблемы
- Заключение
Введение
Большинство индикаторов цикла исходят из того, что доминирующая частота остается неизменной в течение времени, достаточного для ее измерения. Рынки опровергают это предположение. Цикл, который в спокойную торговую сессию занимает 18 баров, может сократиться до 11 с притоком ликвидности, так что сам цикл меняет форму, пока вы его измеряете. Специалисты по обработке сигналов называют это чирп-сигналом: тоном, мгновенная частота которого плавно изменяется.
Дробное преобразование Фурье (FrFT) позволяет взглянуть на проблему с другой стороны. Вместо того чтобы спрашивать, какая частота присутствует в окне, мы спрашиваем, при каком угле поворота энергия окна достигает максимальной концентрации. Для одиночного чирп-сигнала с линейной частотной модуляцией (ЛЧМ-сигнала) этот угол связан со скоростью изменения частоты, поэтому один поиск на каждом баре позволяет определить, ускоряется или замедляется доминирующий цикл. Эта идея опирается на модель сигнала с жесткими ограничениями, и значительная часть статьи посвящена оценке того, насколько окна реальных ценовых данных отклоняются от этой модели.
Мы создаем индикатор средствами самого MQL5 без DLL и внешних библиотек, показываем, почему две естественные реализации не работают, и тестируем итоговую реализацию на синтетических чирп-сигналах и реальных ценах закрытия. На синтетических данных получены хорошие результаты. На реальных ценах закрытия показания индикатора не несут измеримой прогностической информации, и в разделе 11 этот результат представлен как есть.
Примечание по тематике: данная статья посвящена обработке сигналов и построению индикаторов. Ничто из представленного здесь не является торговой системой, и никаких заявлений о получении прибыли не делается. Рассматривайте индикатор как средство измерения характеристик текущего окна данных и протестируйте его на своих торговых инструментах, прежде чем использовать в качестве фильтра.
Почему поворот, а не плотность
Временно-частотные распределения семейства Вигнера — Вилля дают полную двумерную картину распределения энергии по времени и частоте. Они квадратичны, требуют сглаживания для подавления перекрестных членов и дают поверхность, из которой еще нужно извлечь информацию, анализируя ее сечения или прослеживая на ней траектории.
FrFT представляет собой линейное унитарное обобщение преобразования Фурье, при котором плоскость "время-частота" поворачивается на произвольный угол. Порядок a = 0 соответствует исходному ряду, a = 1 — обычному преобразованию Фурье, а a = 2 — ряду, обращенному во времени. В непрерывной теории ЛЧМ-сигнал при одном определенном порядке преобразования превращается в одиночный узкий пик. Поэтому мы перебираем значения порядка, выбираем то, которое дает наибольшую концентрацию, и пересчитываем его в скорость изменения частоты, сводя двумерную задачу к одномерному поиску. Без настройки здесь не обойтись: длина окна, диапазон порядков, сохраняемая полоса, удаление тренда, мера энтропии и допущение о наличии одного доминирующего чирп-сигнала — все это требует выбора. В разделе 12 перечислено, что измерялось для каждого из этих пунктов.
Математика: чирп-сигналы, поворот и концентрация
При угле поворота α = aπ/2 непрерывное дробное преобразование Фурье (FrFT) выполняет интегрирование с ядром в виде чирп-сигнала. Важно, как это преобразование действует на ЛЧМ-сигнал x(t) = cos(2π(f₀t + μt²/2)): чирп-сигнал концентрируется в узком пике при порядке, для которого cot α = −μ, и остается размытым при всех остальных порядках. Обычное БПФ соответствует только порядку a = 1, поэтому любой цикл с изменяющейся частотой в обычном спектре оказывается размытым.
Единицы измерения. Дискретное преобразование охватывает √n единиц как по времени, так и по частоте, поэтому чирп-сигнал, частота которого изменяется со скоростью κ циклов на бар², имеет нормированную скорость κ·n и фокусируется при cot α = −κ·n. Следовательно, μ̂ = −cot α* равно κ·n — полному изменению доминирующей частоты за окно из n баров, выраженному в циклах на бар. Этот вывод справедлив для непрерывного преобразования. Для дискретного преобразования этот вывод проверяется численно в разделе 10, где также отмечается систематическое смещение. Для окна из 64 баров, в котором цикл ускоряется и его период сокращается с 20 баров (0,05 цикла на бар) до 10 баров (0,10), оценка составляет μ̂ ≈ +0,05; положительный знак означает, что цикл сжимается.
Для измерения концентрации мы используем энтропию Реньи второго порядка нормализованного спектра мощности. Она мала, когда энергия сосредоточена в небольшом числе спектральных отсчетов, а нормировка по полной мощности делает ее независимой от масштаба сигнала. Минимизация энтропии по a позволяет найти порядок, при котором доминирующий чирп-сигнал наиболее сконцентрирован.
α = a·π/2 α* = a*·π/2 μ̂ = −cot(α*) = −cos(α*)/sin(α*) H2(a) = −log( Σ_m p_m² ), p_m = |X_a[m]|² / Σ_j |X_a[j]|²
Две проблемы, нарушающие работу простейшей реализации индикатора FrFT
Ядро нельзя просто дискретизировать. Прямой способ программной реализации дробного преобразования Фурье (FrFT) — вычислить значения ядра, заданного аналитической формулой, в n отсчетах. Дискретизированное ядро задает корректное преобразование только при a = 1. При отклонении от этого значения фаза изменяется быстрее, чем можно отследить по n отсчетам: на краю окна скорость ее изменения достигает (|cot α| + |csc α|)/2 циклов на отсчет, что превышает предел Найквиста, равный половине цикла на отсчет, и матрица перестает быть унитарной. Результаты измерений на окне из 64 отсчетов:
| Порядок a | max |KHK − I| | Наименьшее сингулярное число | Наибольшее сингулярное число |
|---|---|---|---|
| 0,60 | 1,087 | ≈ 0 | 1,878 |
| 0,85 | 0,935 | 0,008 | 1,541 |
| 0,95 | 0,228 | 0,814 | 1,198 |
| 1,15 | 0,935 | 0,008 | 1,541 |
| 1,40 | 1,087 | ≈ 0 | 1,878 |
При a = 0,60 и 1,40 наименьшее сингулярное число практически равно нулю, а наибольшее — 1,88, поэтому одни направления полностью подавляются, другие усиливаются, и обратной матрицы не существует. Любой метод, основанный на этой матрице, измеряет свойства дискретизации, а не сигнала. Алгоритм, рассматриваемый в данной статье, позволяет избежать этой проблемы за счет построения унитарного преобразования (раздел 5).
Вещественный входной сигнал скрывает знак. Для вещественного входного сигнала спектр при порядке 2 − a является зеркальным отражением спектра при порядке a, поэтому H2(a) = H2(2 − a) (на тестовом окне на рис. 1 эти две величины совпадают с точностью до 2,2e-15), а кривая энтропии симметрична относительно a = 1. Вещественный чирп-сигнал представляет собой сумму чирп-сигнала и его комплексно сопряженного сигнала, которые концентрируются при зеркально расположенных значениях порядка, поэтому возникают два одинаково глубоких минимума — на рисунке они находятся вблизи 0,83 и 1,17. Знак a* − 1 совпадает со знаком скорости изменения частоты, а при вещественном входном сигнале он определяется тем, какой из минимумов поиск находит первым.

Рис. 1. Зависимость энтропии Реньи от дробного порядка для одного зашумленного тестового чирп-сигнала с c = +0,25. Оранжевым показана кривая для окна вещественного сигнала с двумя зеркально расположенными минимумами. Синим показана кривая для аналитического сигнала того же окна с единственным минимумом (отмечен маркером) по нужную сторону от пунктирной линии a = 1.
На рис. 2 приведены количественные результаты для 400 зашумленных тестовых чирп-сигналов со случайными значениями скорости изменения частоты, несущей частоты и фазы. Оценки по вещественному входному сигналу принимают оба знака независимо от истинного знака (совпадение знаков — 50%, как при подбрасывании монеты), тогда как оценки по аналитическому сигналу располагаются на диагонали (99,5%).

Рис. 2. Зависимость оцененной скорости изменения частоты от истинной для 400 зашумленных тестовых чирп-сигналов. Оранжевым показаны результаты поиска порядка по окну вещественного сигнала. Синим — результаты поиска порядка по аналитическому сигналу. Пунктирная линия представляет собой идеальную оценку.
Решением является аналитический сигнал: обнулите половину спектра с отрицательными частотами, удвойте половину с положительными частотами и выполните обратное преобразование. Тогда в окне остается только один из двух комплексно сопряженных чирп-сигналов, кривая его энтропии имеет единственный минимум, а положение этого минимума относительно a = 1 определяет знак скорости изменения частоты. Вычислительный модуль выполняет эту операцию на каждом баре для окна после удаления тренда, непосредственно перед поиском порядка.
Преобразование, унитарное по построению
Используем построение дискретного дробного преобразования Фурье (FrFT) на основе собственных векторов. Матрица дискретного преобразования Фурье (ДПФ; англ. DFT) F имеет всего четыре собственных значения (1, −i, −1, i), которым соответствуют собственные подпространства большой размерности, поэтому для определения дробных степеней требуется конкретный выбор базиса. Мы выбираем базис, векторы которого ведут себя подобно дискретизированным функциям Эрмита — собственным функциям непрерывного преобразования Фурье, — используя вещественную симметричную матрицу S, коммутирующую с F (на главной диагонали стоят 2cos(2πk/n) − 4, на соседних диагоналях — единицы, причем соседство циклически замыкается через угловые элементы). Присвоим каждому собственному вектору порядок p = 0, 1, 2, … и умножим его коэффициент на exp(−iπap/2):
Fᵃ = V · diag( exp(−i·π·a·p_j/2) ) · V′ V: columns are the eigenvectors of S
Алгебраические свойства выполняются точно. При a = 1 получается ДПФ, при a = 2 — обращение во времени, преобразование унитарно при любом a, порядки складываются, а преобразование порядка −a является обратным к преобразованию порядка a. В разделе 10 показано, что эти тождества выполняются с точностью примерно до 1e-13. Унитарность обеспечивает сохранение нормы и корректность сравнения энтропии при разных порядках преобразования. Однако это не означает, что минимум энтропии соответствует физической скорости изменения частоты. Это отдельный вопрос, и единственное подтверждение такого соответствия — результаты измерений в разделе 10.
Для собственных векторов важны три решения. Во-первых, у матрицы S есть пары совпадающих собственных значений (минимальная разность составляет 1,8e-15 при n = 64), и алгоритм решения может смешивать векторы из разных собственных подпространств матрицы F. Поэтому вычислительный модуль решает задачу отдельно в четном и нечетном подпространствах. Каждому из них соответствует тридиагональный блок с различными собственными значениями. Во-вторых, в нем используется собственная детерминированная реализация циклического метода Якоби объемом около тридцати строк, поэтому версия на Python и вычислительный модуль на MQL5 выполняют один и тот же алгоритм. В-третьих, модуль упорядочивает векторы по числу смен знака в окрестности центра окна, поскольку во второй половине спектра сортировка по собственным значениям матрицы S дает неверные результаты. Таким образом, получается правильный порядок первых 46 векторов при n = 64.
Оставшиеся 18 векторов соответствуют частотам вблизи частоты Найквиста, где число смен знака достигает насыщения. Для этих векторов вычислительный модуль определяет, к какому классу собственных значений ДПФ относится каждый вектор, и назначает оставшиеся порядки так, чтобы их остатки по модулю 4 соответствовали нужным классам. Это гарантирует, что при a = 1 воспроизводится ДПФ, а при a = 2 — обращение во времени. Для дробного a такое назначение порядков является условностью. На эти векторы приходится около 4% энергии окна случайного блуждания, 8% энергии зашумленного чирп-сигнала и до 23% энергии в отдельных окнах. Я измерил влияние этой условности, назначив порядки внутри каждого класса в обратной последовательности. На 300 тестовых чирп-сигналах медиана изменения μ̂ составила 0,0006, а максимальное изменение — 0,010; знак оценки ни разу не изменился. На 220 окнах реальных данных медиана изменения равнялась нулю, знак оценки менялся в 0,9% окон, а наибольшее изменение составляло 0,45. Эта условность влияет на результат лишь в отдельных редких окнах, а не в типичном окне.
Init проверяет результаты своей работы: убеждается, что алгоритм сошелся, а также проверяет невязку каждого разложения по собственным векторам (наихудшее значение по всем 57 четным размерам от 16 до 128 — 6,0e-14; значения выше 1e-9 не допускаются) и запас для каждого класса собственных значений ДПФ (минимальное значение — 1,0000; значения ниже 0,5 не допускаются). При провале любой проверки функция возвращает false, оставляя объект пустым и непригодным для использования. Вычислительный модуль также отклоняет размеры вне диапазона от 16 до 128. Ниже приведены объявления, метод Якоби, проверка невязки и инициализатор:
CFrFTEngine (объявления)
//+------------------------------------------------------------------+ //| Engine defaults | //+------------------------------------------------------------------+ #define FRFT_DEFAULT_WINDOW 64 // analysis window, bars #define FRFT_DEFAULT_AMIN 0.60 // order search, lower bound #define FRFT_DEFAULT_AMAX 1.40 // order search, upper bound #define FRFT_DEFAULT_GSS_TOL 0.001 // golden-section bracket width #define FRFT_DEFAULT_GSS_ITER 40 // golden-section iteration cap #define FRFT_DEFAULT_BAND 0.08 // kept band, fraction of window #define FRFT_MAX_WINDOW 128 // largest validated window #define FRFT_DEFAULT_MIN_GAIN 0.40 // focus gain below which a reading is flagged, nats (n = 64)
CFrFTEngine
//+------------------------------------------------------------------+ //| CFrFTEngine | //| Unitary discrete FrFT built from Hermite-like | //| eigenvectors of the DFT-commuting matrix S. | //+------------------------------------------------------------------+ class CFrFTEngine { private: int m_n; // window length (even) int m_h; // n/2 double m_vt[]; // eigenvectors, vector j at m_vt[j*n .. j*n+n-1] double m_ord[]; // Hermite-like order of vector j double m_mask[]; // analytic-signal mask per DFT bin double m_zr[]; // analytic window, real part, centered double m_zi[]; // analytic window, imaginary part double m_pr[]; // scratch: V'z, real part double m_pi[]; // scratch: V'z, imaginary part double m_qr[]; // scratch: rotated output, real part double m_qi[]; // scratch: rotated output, imaginary part double m_tr[]; // scratch: temporary, real part double m_ti[]; // scratch: temporary, imaginary part double m_fr[]; // scratch: kept band, real part double m_fi[]; // scratch: kept band, imaginary part bool Jacobi(double &a[],const int d,double &w[],double &v[]); double Residual(const double &a0[],const int d,const double &w[],const double &v[]); public: CFrFTEngine(void) : m_n(0),m_h(0) {} bool Init(const int n); int Size(void) const { return(m_n); } void Project(const double &zr[],const double &zi[],double &yr[],double &yi[]); void Rotate(const double &yr[],const double &yi[],const double a, double &xr[],double &xi[]); void AnalyticShifted(const double &x[]); double RenyiEntropy2(const double &re[],const double &im[]); double SearchOptimalOrder(const double &yr[],const double &yi[], const double a_min,const double a_max, const double tol,const int max_iter, double &best_entropy); double ReconstructLast(const double &yr[],const double &yi[], const double a_star,const double band_frac); bool CalcBar(const double &win[],const double a_min,const double a_max, const double tol,const int max_iter,const double band_frac, double &cycle,double &a_star,double &gain); static double LinearDetrend(const double &src[],const int n,double &out[], double &slope,double &intercept); };
CFrFTEngine::Jacobi
//+------------------------------------------------------------------+ //| CFrFTEngine::Jacobi | //| Cyclic Jacobi eigen-solver, symmetric d x d, row-major. | //| v[k*d+j] = component k of eigenvector j. Returns false if | //| the off-diagonal norm has not converged. | //+------------------------------------------------------------------+ bool CFrFTEngine::Jacobi(double &a[],const int d,double &w[],double &v[]) { ArrayResize(v,d*d); ArrayInitialize(v,0.0); for(int i=0;i<d;i++) v[i*d+i]=1.0; bool ok=false; for(int sweep=0;sweep<60;sweep++) { double off=0.0; for(int p=0;p<d-1;p++) for(int q=p+1;q<d;q++) off+=a[p*d+q]*a[p*d+q]; if(off<1e-26) { ok=true; break; } for(int p=0;p<d-1;p++) for(int q=p+1;q<d;q++) { double apq=a[p*d+q]; if(MathAbs(apq)<1e-300) continue; double th=(a[q*d+q]-a[p*d+p])/(2.0*apq); double t =(th>=0.0 ? 1.0 : -1.0)/(MathAbs(th)+MathSqrt(th*th+1.0)); double c =1.0/MathSqrt(t*t+1.0); double s =t*c; for(int k=0;k<d;k++) { double akp=a[k*d+p], akq=a[k*d+q]; a[k*d+p]=c*akp-s*akq; a[k*d+q]=s*akp+c*akq; } for(int k=0;k<d;k++) { double apk=a[p*d+k], aqk=a[q*d+k]; a[p*d+k]=c*apk-s*aqk; a[q*d+k]=s*apk+c*aqk; } for(int k=0;k<d;k++) { double vkp=v[k*d+p], vkq=v[k*d+q]; v[k*d+p]=c*vkp-s*vkq; v[k*d+q]=s*vkp+c*vkq; } } } if(!ok) { double off=0.0; for(int p=0;p<d-1;p++) for(int q=p+1;q<d;q++) off+=a[p*d+q]*a[p*d+q]; ok=(off<1e-26); } ArrayResize(w,d); for(int i=0;i<d;i++) w[i]=a[i*d+i]; return(ok); }
CFrFTEngine::Residual
//+------------------------------------------------------------------+ //| CFrFTEngine::Residual | //| Largest entry of A*V - V*diag(w), with A the matrix before | //| it was diagonalized. Checks the eigen-decomposition itself. | //+------------------------------------------------------------------+ double CFrFTEngine::Residual(const double &a0[],const int d,const double &w[],const double &v[]) { double worst=0.0; for(int j=0;j<d;j++) for(int i=0;i<d;i++) { double s=0.0; for(int k=0;k<d;k++) s+=a0[i*d+k]*v[k*d+j]; worst=MathMax(worst,MathAbs(s-w[j]*v[i*d+j])); } return(worst); }
CFrFTEngine::Init
//+------------------------------------------------------------------+ //| CFrFTEngine::Init | //| Builds the eigenbasis and assigns each vector its | //| Hermite-like order. Returns false, leaving the object | //| unusable, on a bad size or a failed internal check. | //+------------------------------------------------------------------+ bool CFrFTEngine::Init(const int n) { if(n<16 || n>FRFT_MAX_WINDOW || (n&1)!=0) return(false); m_n=0; m_h=0; int h=n/2; double r2=MathSqrt(2.0); //--- S restricted to even and odd vectors: two tridiagonal blocks int de=h+1, dd=h-1; double Ae[],Ao[]; ArrayResize(Ae,de*de); ArrayResize(Ao,dd*dd); ArrayInitialize(Ae,0.0); ArrayInitialize(Ao,0.0); for(int j=0;j<=h;j++) Ae[j*de+j]=2.0*MathCos(2.0*M_PI*j/n)-4.0; for(int j=0;j<dd;j++) Ao[j*dd+j]=2.0*MathCos(2.0*M_PI*(j+1)/n)-4.0; Ae[0*de+1]=Ae[1*de+0]=r2; Ae[(h-1)*de+h]=Ae[h*de+(h-1)]=r2; for(int j=1;j<h-1;j++) Ae[j*de+j+1]=Ae[(j+1)*de+j]=1.0; for(int j=0;j<dd-1;j++) Ao[j*dd+j+1]=Ao[(j+1)*dd+j]=1.0; double we[],Ue[],wo[],Uo[],Ae0[],Ao0[]; ArrayResize(Ae0,de*de); ArrayResize(Ao0,dd*dd); ArrayCopy(Ae0,Ae); ArrayCopy(Ao0,Ao); bool okE=Jacobi(Ae,de,we,Ue); bool okO=Jacobi(Ao,dd,wo,Uo); //--- refuse a basis whose eigen-decomposition did not converge or is inaccurate if(!okE || !okO || Residual(Ae0,de,we,Ue)>1e-9 || Residual(Ao0,dd,wo,Uo)>1e-9) return(false); //--- expand to full-length vectors: even block first, then odd double vec[],sev[]; ArrayResize(vec,n*n); ArrayResize(sev,n); ArrayInitialize(vec,0.0); for(int i=0;i<de;i++) { int base=i*n; vec[base]=Ue[i]; vec[base+h]=Ue[h*de+i]; for(int j=1;j<h;j++) { double u=Ue[j*de+i]/r2; vec[base+j]=u; vec[base+n-j]=u; } sev[i]=we[i]; } for(int i=0;i<dd;i++) { int base=(de+i)*n; for(int j=1;j<h;j++) { double u=Uo[(j-1)*dd+i]/r2; vec[base+j]=u; vec[base+n-j]=-u; } sev[de+i]=wo[i]; } //--- order by sign changes around the center, ties by S eigenvalue int zc[],idx[]; ArrayResize(zc,n); ArrayResize(idx,n); for(int j=0;j<n;j++) { int cnt=0; double prev=0.0; for(int i=0;i<n;i++) { double c=vec[j*n+(i+h)%n]; if(MathAbs(c)<1e-10) continue; if(prev!=0.0 && c*prev<0.0) cnt++; prev=c; } zc[j]=cnt; idx[j]=j; } for(int i=1;i<n;i++) { int key=idx[i]; int p=i-1; while(p>=0 && (zc[key]<zc[idx[p]] || (zc[key]==zc[idx[p]] && sev[key]>sev[idx[p]]))) { idx[p+1]=idx[p]; p--; } idx[p+1]=key; } ArrayResize(m_vt,n*n); for(int j=0;j<n;j++) for(int i=0;i<n;i++) m_vt[j*n+i]=vec[idx[j]*n+i]; //--- DFT eigenvalue class of each vector: v'Fv = (-i)^order double ct[],st[]; ArrayResize(ct,n); ArrayResize(st,n); for(int m=0;m<n;m++) { ct[m]=MathCos(2.0*M_PI*m/n); st[m]=MathSin(2.0*M_PI*m/n); } double isq=1.0/MathSqrt((double)n); int cls[],base_ord[]; ArrayResize(cls,n); ArrayResize(base_ord,n); for(int p=0;p<n;p++) { double lr=0.0,li=0.0; for(int j=0;j<n;j++) for(int k=0;k<n;k++) { double vv=m_vt[p*n+j]*m_vt[p*n+k]; int mm=(j*k)%n; lr+=vv*ct[mm]; li-=vv*st[mm]; } lr*=isq; li*=isq; double sc[4]; sc[0]=lr; sc[1]=-li; sc[2]=-lr; sc[3]=li; int best=0; for(int c=1;c<4;c++) if(sc[c]>sc[best]) best=c; double second=-2.0; for(int c=0;c<4;c++) if(c!=best && sc[c]>second) second=sc[c]; if(sc[best]-second<0.5) // a true eigenvector of F scores 1 against 0 return(false); cls[p]=best; base_ord[p]=(p<n-1) ? p : n; } //--- zero-crossing rank is exact for low orders; match the rest by class ArrayResize(m_ord,n); int good=0; while(good<n && cls[good]==base_ord[good]%4) good++; for(int p=0;p<good;p++) m_ord[p]=base_ord[p]; for(int c=0;c<4;c++) { int slot=good; for(int v=good;v<n;v++) { if(cls[v]!=c) continue; while(slot<n && base_ord[slot]%4!=c) slot++; if(slot>=n) return(false); m_ord[v]=base_ord[slot]; slot++; } } //--- analytic-signal mask on DFT bins ArrayResize(m_mask,n); ArrayInitialize(m_mask,0.0); m_mask[0]=1.0; m_mask[h]=1.0; for(int k=1;k<h;k++) m_mask[k]=2.0; ArrayResize(m_zr,n); ArrayResize(m_zi,n); ArrayResize(m_pr,n); ArrayResize(m_pi,n); ArrayResize(m_qr,n); ArrayResize(m_qi,n); ArrayResize(m_tr,n); ArrayResize(m_ti,n); ArrayResize(m_fr,n); ArrayResize(m_fi,n); m_n=n; m_h=h; return(true); }
Методы Project и Rotate и аналитический сигнал
Поскольку Fa = V·diag·V′, половина вычислений не зависит от порядка. Метод Project вычисляет y = V′z один раз на бар, после чего для каждого проверяемого порядка требуется лишь одно умножение на фазовые множители и одно умножение на V, что и выполняет метод Rotate. Собственные векторы хранятся по одному в каждой строке плоского массива, поэтому оба цикла проходят по непрерывному участку памяти.
CFrFTEngine::Project
//+------------------------------------------------------------------+ //| CFrFTEngine::Project | //| y = V' z, the order-independent half of the transform. | //+------------------------------------------------------------------+ void CFrFTEngine::Project(const double &zr[],const double &zi[],double &yr[],double &yi[]) { int n=m_n; if(n==0) return; for(int j=0;j<n;j++) { int base=j*n; double sr=0.0,si=0.0; for(int i=0;i<n;i++) { double v=m_vt[base+i]; sr+=v*zr[i]; si+=v*zi[i]; } yr[j]=sr; yi[j]=si; } }
CFrFTEngine::Rotate
//+------------------------------------------------------------------+ //| CFrFTEngine::Rotate | //| x = V diag(exp(-i*pi/2*a*order)) y, i.e. FrFT of order a. | //| Order -a is the exact inverse of order a. | //+------------------------------------------------------------------+ void CFrFTEngine::Rotate(const double &yr[],const double &yi[],const double a, double &xr[],double &xi[]) { int n=m_n; if(n==0) return; double k=-0.5*M_PI*a; ArrayInitialize(xr,0.0); ArrayInitialize(xi,0.0); for(int j=0;j<n;j++) { double ph=k*m_ord[j]; double c=MathCos(ph), s=MathSin(ph); double wr=yr[j]*c-yi[j]*s; double wi=yr[j]*s+yi[j]*c; int base=j*n; for(int i=0;i<n;i++) { double v=m_vt[base+i]; xr[i]+=wr*v; xi[i]+=wi*v; } } }
Метод AnalyticShifted формирует аналитический сигнал с помощью того же механизма: преобразование порядка 1 соответствует ДПФ, маска сохраняет спектральный отсчет 0 и отсчет Найквиста, удваивает спектральные отсчеты от 1 до n/2 − 1 и отбрасывает остальные, а преобразование порядка −1 возвращает окно во временную область. Заключительный циклический сдвиг перемещает центр окна в позицию с индексом 0, поскольку при построении S индекс 0 принят за начало отсчета времени.
CFrFTEngine::AnalyticShifted
//+------------------------------------------------------------------+ //| CFrFTEngine::AnalyticShifted | //| Analytic signal of a real window via the DFT (order 1), | //| rolled so the window center sits at index 0. Result in | //| m_zr/m_zi. | //+------------------------------------------------------------------+ void CFrFTEngine::AnalyticShifted(const double &x[]) { int n=m_n, h=m_h; if(n==0) return; for(int i=0;i<n;i++) { m_tr[i]=x[i]; m_ti[i]=0.0; } Project(m_tr,m_ti,m_pr,m_pi); Rotate(m_pr,m_pi,1.0,m_qr,m_qi); for(int k=0;k<n;k++) { m_qr[k]*=m_mask[k]; m_qi[k]*=m_mask[k]; } Project(m_qr,m_qi,m_pr,m_pi); Rotate(m_pr,m_pi,-1.0,m_tr,m_ti); for(int i=0;i<n;i++) { m_zr[i]=m_tr[(i+h)%n]; m_zi[i]=m_ti[(i+h)%n]; } }
Поиск оптимального порядка
Прямой перебор 200 значений порядка на каждом баре потребовал бы 200 поворотов. Поиск методом золотого сечения на каждом шаге повторно использует одно ранее вычисленное значение, поэтому при допуске по умолчанию 0,001 и ширине исходного интервала 0,8 требуется 16 вычислений.
CFrFTEngine::RenyiEntropy2
//+------------------------------------------------------------------+ //| CFrFTEngine::RenyiEntropy2 | //| Order-2 Rényi entropy of |X|^2 / sum|X|^2. Lower means a | //| more concentrated spectrum. | //+------------------------------------------------------------------+ double CFrFTEngine::RenyiEntropy2(const double &re[],const double &im[]) { double total=0.0, sum2=0.0; for(int i=0;i<m_n;i++) { double m2=re[i]*re[i]+im[i]*im[i]; total+=m2; sum2+=m2*m2; } if(total<=0.0) return(0.0); double s=sum2/(total*total); if(s<1e-15) s=1e-15; return(-MathLog(s)); }
CFrFTEngine::SearchOptimalOrder
//+------------------------------------------------------------------+ //| CFrFTEngine::SearchOptimalOrder | //| Golden-section search for the order in [a_min,a_max] | //| that minimizes Rényi entropy. y = V' z of the window. | //+------------------------------------------------------------------+ double CFrFTEngine::SearchOptimalOrder(const double &yr[],const double &yi[], const double a_min,const double a_max, const double tol,const int max_iter, double &best_entropy) { double gr=(MathSqrt(5.0)-1.0)/2.0; double lo=a_min, hi=a_max; double c=hi-gr*(hi-lo); double d=lo+gr*(hi-lo); Rotate(yr,yi,c,m_qr,m_qi); double fc=RenyiEntropy2(m_qr,m_qi); Rotate(yr,yi,d,m_qr,m_qi); double fd=RenyiEntropy2(m_qr,m_qi); int iter=0; while(MathAbs(hi-lo)>tol && iter<max_iter) { if(fc<fd) { hi=d; d=c; fd=fc; c=hi-gr*(hi-lo); Rotate(yr,yi,c,m_qr,m_qi); fc=RenyiEntropy2(m_qr,m_qi); } else { lo=c; c=d; fc=fd; d=lo+gr*(hi-lo); Rotate(yr,yi,d,m_qr,m_qi); fd=RenyiEntropy2(m_qr,m_qi); } iter++; } best_entropy=MathMin(fc,fd); return((lo+hi)/2.0); }
Важны два ограничения. Диапазон поиска должен включать a = 1, поскольку знак скорости изменения частоты определяется тем, по какую сторону от 1 находится оптимум; другие диапазоны индикаторы не принимают. Кроме того, диапазон задает максимальную измеримую скорость изменения частоты: на его границах |μ̂| = cot(0,6·π/2) = 0,727, а за этими пределами гистограмма насыщается.
Поиск методом золотого сечения предполагает наличие одного минимума, поэтому я сравнил его результаты с результатами полного перебора по 161 точке на 200 окнах каждого типа:
| Тип окна | Результат поиска отличается от результата полного перебора более чем на 0,02 | Более чем на 0,10 |
|---|---|---|
| Один чирп-сигнал + шум | 2% | 1% |
| Случайное блуждание | 8% | 6% |
| Два чирп-сигнала | 30% | 28% |
Для одного чирп-сигнала поиск надежен. В случайном блуждании нет чирп-сигнала, который можно было бы обнаружить, и результаты поиска и полного перебора расходятся примерно в одном случае из двенадцати. Для двух чирп-сигналов результаты поиска и полного перебора расходятся примерно в трех случаях из десяти, поскольку на кривой действительно есть два конкурирующих минимума.
Насколько можно доверять показаниям. Поиск возвращает порядок для каждого окна, в том числе для окон без чирп-сигнала, поэтому индикатору нужна собственная мера достоверности: выигрыш в концентрации G = H2(a = 1) − H2(a*), выраженный в натах. Для чирп-сигнала выигрыш в концентрации по сравнению с обычным спектром велик, а для случайного блуждания — мал. Порог 0,40 соответствует 95-му процентилю G по окнам случайного блуждания при n = 64 (0,404 в моем калибровочном прогоне):
| Тип окна | Окна | Медианный выигрыш в концентрации, нат | Доля окон с G выше 0,40 |
|---|---|---|---|
| Один чирп-сигнал | 400 | 1,460 | 98,2% |
| Случайное блуждание | 400 | 0,067 | 5,0% |
| Тон постоянной частоты | 400 | 0,001 | 0,0% |
| Два чирп-сигнала | 400 | 0,493 | 62,0% |
| Реальные цены закрытия | 1023 | 0,070 | 5,1% |
G хорошо отличает чирп-сигнал от случайного блуждания (площадь под ROC-кривой составляет 0,998), а для окон реальных данных порог превышается в 5,1% случаев, что в точности соответствует предсказанию нулевой гипотезы. Однако G не выявляет окна с двумя чирп-сигналами (для 62% таких окон порог превышен): большой выигрыш в концентрации означает наличие фокусировки, но не гарантирует, что в окне присутствует только один чирп-сигнал. Бары со значениями ниже порога отображаются серым цветом.
От порядка к линии цикла
Знание a* само по себе не дает линии цикла. Индикатор выполняет прямое преобразование окна после удаления тренда с порядком a*, сохраняет полосу спектральных отсчетов вокруг максимума модуля, обнуляет остальные отсчеты и выполняет обратное преобразование с порядком −a*. Значение линии — это вещественная часть результата на последнем отсчете окна, поэтому для ее расчета используются только цены закрытия до текущего бара включительно. Сначала выполняется удаление линейного тренда, и этот этап обязателен: исходное окно цен закрытия содержит значительную постоянную составляющую и составляющую с линейным наклоном, которые заглушили бы цикл. Алгоритм подбирает прямую методом наименьших квадратов, преобразует остаток после вычитания тренда и добавляет тренд обратно в последней точке.
CFrFTEngine::ReconstructLast
//+------------------------------------------------------------------+ //| CFrFTEngine::ReconstructLast | //| Keeps a band around the peak bin at order a_star, inverts | //| with order -a_star, returns the real part at the last | //| window sample. | //+------------------------------------------------------------------+ double CFrFTEngine::ReconstructLast(const double &yr[],const double &yi[], const double a_star,const double band_frac) { int n=m_n; Rotate(yr,yi,a_star,m_qr,m_qi); int peak=0; double top=-1.0; for(int i=0;i<n;i++) { double m2=m_qr[i]*m_qr[i]+m_qi[i]*m_qi[i]; if(m2>top) { top=m2; peak=i; } } int hb=(int)MathMax(1.0,MathFloor(band_frac*n/2.0+0.5)); ArrayInitialize(m_fr,0.0); ArrayInitialize(m_fi,0.0); //--- the band is not wrapped: the analytic signal is empty past either edge, //--- and wrapping changed the cycle value by 0.4% of the window deviation for(int i=peak-hb;i<=peak+hb;i++) { if(i<0 || i>=n) continue; m_fr[i]=m_qr[i]; m_fi[i]=m_qi[i]; } Project(m_fr,m_fi,m_tr,m_ti); Rotate(m_tr,m_ti,-a_star,m_qr,m_qi); return(m_qr[m_h-1]); }
CFrFTEngine::LinearDetrend
//+------------------------------------------------------------------+ //| CFrFTEngine::LinearDetrend | //| Least-squares line removed from src. Returns the trend | //| value at the last sample. | //+------------------------------------------------------------------+ double CFrFTEngine::LinearDetrend(const double &src[],const int n,double &out[], double &slope,double &intercept) { double sx=0.0, sy=0.0, sxx=0.0, sxy=0.0; for(int i=0;i<n;i++) { sx+=i; sy+=src[i]; sxx+=(double)i*i; sxy+=(double)i*src[i]; } double den=n*sxx-sx*sx; slope =(den!=0.0) ? (n*sxy-sx*sy)/den : 0.0; intercept=(sy-slope*sx)/n; ArrayResize(out,n); for(int i=0;i<n;i++) out[i]=src[i]-(slope*i+intercept); return(slope*(n-1)+intercept); }
CFrFTEngine::CalcBar
//+------------------------------------------------------------------+ //| CFrFTEngine::CalcBar | //| One indicator bar: detrend, analytic signal, order search, | //| band reconstruction. cycle includes the trend again. | //| gain = H2(a=1) - H2(a*), nats: how much sharper the focus | //| at a* is than in the ordinary spectrum. | //+------------------------------------------------------------------+ bool CFrFTEngine::CalcBar(const double &win[],const double a_min,const double a_max, const double tol,const int max_iter,const double band_frac, double &cycle,double &a_star,double &gain) { if(m_n==0) return(false); double dt[]; double slope,intercept,best; LinearDetrend(win,m_n,dt,slope,intercept); AnalyticShifted(dt); Project(m_zr,m_zi,m_pr,m_pi); a_star=SearchOptimalOrder(m_pr,m_pi,a_min,a_max,tol,max_iter,best); Rotate(m_pr,m_pi,1.0,m_qr,m_qi); gain=RenyiEntropy2(m_qr,m_qi)-best; cycle=ReconstructLast(m_pr,m_pi,a_star,band_frac)+slope*(m_n-1)+intercept; return(true); }
При достижении границы массива полоса не переносится циклически на противоположный край. Это не создает проблем: вблизи a = 1 за границей находятся спектральные отсчеты отрицательных частот, уже обнуленные на этапе формирования аналитического сигнала; при проверке на 1023 окнах реальных данных циклический перенос изменил значение цикла на 0,4% стандартного отклонения окна по медиане и на 5,8% по 95-му процентилю.
Улучшает ли адаптивный порядок линию цикла? Я запускал индикатор бар за баром на известном цикле с колеблющейся частотой: один раз с порядком, найденным поиском, и один раз с a = 1, для четырех значений ширины сохраняемой полосы. В таблице приведена корреляция с циклом без шума (три реализации по 1200 баров с разными начальными значениями генератора случайных чисел):
| Размах колебаний | Сохраняемая полоса | Адаптивный порядок | Фиксированный порядок a = 1 |
|---|---|---|---|
| Сильный | 0,04 | 0,646 | 0,538 |
| Сильный | 0,08 | 0,719 | 0,717 |
| Сильный | 0,15 | 0,747 | 0,747 |
| Сильный | 0,30 | 0,781 | 0,780 |
| Очень сильный | 0,04 | 0,582 | 0,505 |
| Очень сильный | 0,08 | 0,695 | 0,653 |
| Очень сильный | 0,15 | 0,735 | 0,755 |
| Очень сильный | 0,30 | 0,778 | 0,796 |

Рис. 3. Корреляция между восстановленной линией и чистым циклом в зависимости от ширины сохраняемой полосы для очень сильного колебания. Синим показан адаптивный порядок, оранжевым — фиксированный порядок a = 1.
Адаптивный порядок дает преимущество только при узких полосах. При более широких полосах обычное преобразование Фурье с выделением полосы дает такой же результат, а при наибольшем колебании — даже лучший. Ширина полосы по умолчанию, равная 0,08, сохраняет преимущество и обеспечивает корреляцию около 0,7, поэтому линия цикла — это каузальная оценка цикла, ограниченная по полосе частот, а не сглаживающий фильтр, который перенастраивается без каких-либо потерь.
Два индикатора
Индикатор FrFT_ChirpCycle запускает вычислительный модуль один раз на каждом баре, строит линию цикла и сохраняет a* и выигрыш в концентрации в скрытых буферах. Окно на баре i задается как close[i−n+1 ... i], поэтому значение на закрытом баре никогда не меняется, а советник должен считывать значение со сдвигом 1. Индикатор FrFT_ChirpRate загружает его через iCustom и отображает μ̂ = −cot(a*π/2) в виде цветной гистограммы: зеленый цвет соответствует растущей частоте, красный — падающей, а серый — участкам, где выигрыш в концентрации ниже InpMinGain. Он дублирует все входные параметры индикатора цикла и передает их ему, поэтому настройки двух индикаторов не могут разойтись. Оба индикатора отклоняют нечетную или выходящую за допустимые пределы длину окна, диапазон порядка, не содержащий 1, а также неположительные значения допуска или ширины полосы.
FrFT_ChirpCycle (входные параметры)
//+------------------------------------------------------------------+ //| Inputs | //+------------------------------------------------------------------+ input int InpWindow = FRFT_DEFAULT_WINDOW; // Window, even, 16-128 input double InpAMin = FRFT_DEFAULT_AMIN; // Order search, lower bound input double InpAMax = FRFT_DEFAULT_AMAX; // Order search, upper bound input double InpGSSTol = FRFT_DEFAULT_GSS_TOL; // Golden-section tolerance input int InpGSSMaxIter = FRFT_DEFAULT_GSS_ITER; // Golden-section iteration cap input double InpReconBand = FRFT_DEFAULT_BAND; // Kept band, fraction of window input int InpMaxBarsInit = 2000; // Bars computed on first attach input bool InpLogTiming = false; // Print average us per bar
FrFT_ChirpCycle (глобальные переменные)
//+------------------------------------------------------------------+ //| Globals | //+------------------------------------------------------------------+ CFrFTEngine g_engine; // eigenbasis and transform double BufCycle[]; // plotted cycle line double BufOrder[]; // a* per bar, read by FrFT_ChirpRate double BufGain[]; // focus gain per bar (nats), read by FrFT_ChirpRate ulong g_us = 0; // microseconds spent in the bar loop long g_bars = 0; // bars computed
FrFT_ChirpCycle: OnInit
//+------------------------------------------------------------------+ //| OnInit | //+------------------------------------------------------------------+ int OnInit() { if(InpWindow<16 || InpWindow>FRFT_MAX_WINDOW || InpWindow%2!=0) { PrintFormat("FrFT_ChirpCycle: InpWindow must be even, 16-%d. Got %d",FRFT_MAX_WINDOW,InpWindow); return(INIT_PARAMETERS_INCORRECT); } if(InpAMin<=0.0 || InpAMax>=2.0 || InpAMin>=1.0 || InpAMax<=1.0) { Print("FrFT_ChirpCycle: order range must lie in (0,2) and contain 1.0"); return(INIT_PARAMETERS_INCORRECT); } if(InpGSSTol<=0.0 || InpGSSMaxIter<1 || InpReconBand<=0.0 || InpReconBand>1.0) { Print("FrFT_ChirpCycle: bad tolerance, iteration cap or band"); return(INIT_PARAMETERS_INCORRECT); } if(!g_engine.Init(InpWindow)) { Print("FrFT_ChirpCycle: engine init failed"); return(INIT_FAILED); } SetIndexBuffer(0,BufCycle,INDICATOR_DATA); SetIndexBuffer(1,BufOrder,INDICATOR_CALCULATIONS); SetIndexBuffer(2,BufGain,INDICATOR_CALCULATIONS); ArraySetAsSeries(BufCycle,false); ArraySetAsSeries(BufOrder,false); ArraySetAsSeries(BufGain,false); PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,InpWindow-1); PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,EMPTY_VALUE); IndicatorSetString(INDICATOR_SHORTNAME,"FrFT Cycle("+IntegerToString(InpWindow)+")"); return(INIT_SUCCEEDED); }
FrFT_ChirpCycle: OnCalculate
//+------------------------------------------------------------------+ //| OnCalculate | //+------------------------------------------------------------------+ int OnCalculate(const int rates_total,const int prev_calculated, const datetime &time[],const double &open[], const double &high[],const double &low[], const double &close[],const long &tick_volume[], const long &volume[],const int &spread[]) { if(rates_total<InpWindow) return(0); if(prev_calculated==0) { ArrayInitialize(BufCycle,EMPTY_VALUE); ArrayInitialize(BufOrder,0.0); // a* is never 0 in a valid range, so 0 means not computed ArrayInitialize(BufGain,0.0); } int start=(prev_calculated<=1) ? InpWindow-1 : prev_calculated-1; //--- deep history: cap the first pass so attaching does not freeze the terminal if(prev_calculated<=1 && rates_total>InpMaxBarsInit) start=MathMax(InpWindow-1,rates_total-InpMaxBarsInit); double win[]; ArrayResize(win,InpWindow); ulong t0=GetMicrosecondCount(); int done=0; for(int i=start;i<rates_total;i++) { for(int k=0;k<InpWindow;k++) win[k]=close[i-InpWindow+1+k]; double cyc,a_star,gain; if(!g_engine.CalcBar(win,InpAMin,InpAMax,InpGSSTol,InpGSSMaxIter,InpReconBand,cyc,a_star,gain)) return(0); BufCycle[i]=cyc; BufOrder[i]=a_star; BufGain[i]=gain; done++; } g_us+=GetMicrosecondCount()-t0; g_bars+=done; return(rates_total); }
FrFT_ChirpCycle: OnDeinit
//+------------------------------------------------------------------+ //| OnDeinit | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { if(InpLogTiming && g_bars>0) PrintFormat("FrFT_ChirpCycle: %I64d bars, %.1f us per bar",g_bars,(double)g_us/(double)g_bars); }
FrFT_ChirpRate (входные параметры)
//+------------------------------------------------------------------+ //| Inputs | //| Same values as the FrFT_ChirpCycle instance being read. | //| InpMinGain belongs to this indicator only. | //+------------------------------------------------------------------+ input int InpWindow = FRFT_DEFAULT_WINDOW; // Window, even, 16-128 input double InpAMin = FRFT_DEFAULT_AMIN; // Order search, lower bound input double InpAMax = FRFT_DEFAULT_AMAX; // Order search, upper bound input double InpGSSTol = FRFT_DEFAULT_GSS_TOL; // Golden-section tolerance input int InpGSSMaxIter = FRFT_DEFAULT_GSS_ITER; // Golden-section iteration cap input double InpReconBand = FRFT_DEFAULT_BAND; // Kept band, fraction of window input int InpMaxBarsInit = 2000; // Bars computed on first attach input double InpMinGain = FRFT_DEFAULT_MIN_GAIN; // Focus gain below which a bar is gray, nats
FrFT_ChirpRate (глобальные переменные)
//+------------------------------------------------------------------+ //| Globals | //+------------------------------------------------------------------+ double BufRate[]; // chirp rate, mu_hat = -cot(a* pi/2) double BufColor[]; // 0 = rising, 1 = falling, 2 = low focus gain int g_handle=INVALID_HANDLE; // FrFT_ChirpCycle instance
FrFT_ChirpRate: OnInit
//+------------------------------------------------------------------+ //| OnInit | //+------------------------------------------------------------------+ int OnInit() { if(InpWindow<16 || InpWindow>FRFT_MAX_WINDOW || InpWindow%2!=0) { PrintFormat("FrFT_ChirpRate: InpWindow must be even, 16-%d. Got %d",FRFT_MAX_WINDOW,InpWindow); return(INIT_PARAMETERS_INCORRECT); } if(InpAMin<=0.0 || InpAMax>=2.0 || InpAMin>=1.0 || InpAMax<=1.0) { Print("FrFT_ChirpRate: order range must lie in (0,2) and contain 1.0"); return(INIT_PARAMETERS_INCORRECT); } if(InpGSSTol<=0.0 || InpGSSMaxIter<1 || InpReconBand<=0.0 || InpReconBand>1.0 || InpMinGain<0.0) { Print("FrFT_ChirpRate: bad tolerance, iteration cap, band or gain threshold"); return(INIT_PARAMETERS_INCORRECT); } SetIndexBuffer(0,BufRate,INDICATOR_DATA); SetIndexBuffer(1,BufColor,INDICATOR_COLOR_INDEX); ArraySetAsSeries(BufRate,false); ArraySetAsSeries(BufColor,false); PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,InpWindow-1); PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,EMPTY_VALUE); IndicatorSetString(INDICATOR_SHORTNAME,"FrFT Chirp Rate("+IntegerToString(InpWindow)+")"); g_handle=iCustom(_Symbol,_Period,"FrFT_ChirpCycle\\FrFT_ChirpCycle", InpWindow,InpAMin,InpAMax,InpGSSTol,InpGSSMaxIter, InpReconBand,InpMaxBarsInit,false); if(g_handle==INVALID_HANDLE) { Print("FrFT_ChirpRate: cannot load FrFT_ChirpCycle, code ",GetLastError()); return(INIT_FAILED); } return(INIT_SUCCEEDED); }
FrFT_ChirpRate: OnCalculate
//+------------------------------------------------------------------+ //| OnCalculate | //+------------------------------------------------------------------+ int OnCalculate(const int rates_total,const int prev_calculated, const datetime &time[],const double &open[], const double &high[],const double &low[], const double &close[],const long &tick_volume[], const long &volume[],const int &spread[]) { if(rates_total<InpWindow) return(0); if(BarsCalculated(g_handle)<rates_total) return(0); if(prev_calculated==0) { ArrayInitialize(BufRate,EMPTY_VALUE); ArrayInitialize(BufColor,0.0); } int start=(prev_calculated<=1) ? InpWindow-1 : prev_calculated-1; if(prev_calculated<=1 && rates_total>InpMaxBarsInit) start=MathMax(InpWindow-1,rates_total-InpMaxBarsInit); //--- newest (rates_total-start) values of the a* and gain buffers, oldest first int need=rates_total-start; double order[],gain[]; ArraySetAsSeries(order,false); ArraySetAsSeries(gain,false); if(CopyBuffer(g_handle,1,0,need,order)!=need || CopyBuffer(g_handle,2,0,need,gain)!=need) return(prev_calculated); for(int i=start;i<rates_total;i++) { double a=order[i-start]; if(a==0.0) // a* = 0 marks a bar the cycle indicator has not computed continue; double alpha=a*M_PI/2.0; double sn=MathSin(alpha); double mu=(MathAbs(sn)>1e-8) ? -MathCos(alpha)/sn : 0.0; BufRate[i]=mu; BufColor[i]=(gain[i-start]<InpMinGain) ? 2 : (mu>=0.0 ? 0 : 1); } return(rates_total); }
FrFT_ChirpRate: OnDeinit
//+------------------------------------------------------------------+ //| OnDeinit | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { if(g_handle!=INVALID_HANDLE) IndicatorRelease(g_handle); }
Проверка
Тождества вычислительного ядра. Эти свойства должны выполняться в точности, поэтому они проверяются первыми. Для случайных комплексных векторов при n = 64:
| Свойство | Максимальная погрешность |
|---|---|
| a = 1: сравнение с непосредственно вычисленным ДПФ | 7,6·10⁻¹⁴ |
| a = 2: сравнение с обращением времени | 3,2·10⁻¹⁴ |
| Отклонение нормы при a = 0,77 | 6,0·10⁻¹⁴ |
| Аддитивность: F(0,3), затем F(0,55) по сравнению с F(0,85) | 2,0·10⁻¹⁴ |
| Обратное преобразование: F(0,85), затем F(−0,85) | 3,0×10⁻¹⁴ |
| Ортонормальность V | 9,8·10⁻¹⁵ |
Точность и систематическое смещение. Для каждого диапазона истинных значений скорости изменения частоты я сгенерировал 300 зашумленных окон (амплитуда 2,4, шум 0,25, случайные несущая частота и фаза, небольшой тренд) и выполнил полный поиск по аналитическому сигналу. Ошибка учитывается со знаком: положительное значение означает, что μ̂ превышает истинную скорость изменения частоты.
| Истинное значение |c| | Окна | Совпадение знаков | Средняя ошибка с учетом знака | от 5-го до 95-го процентиля | Доля оценок с ошибкой более 50% |
|---|---|---|---|---|---|
| от 0,01 до 0,03 | 300 | 100,0% | +13% | от -15% до +50% | 7% |
| от 0,03 до 0,06 | 300 | 100,0% | +13% | от -4% до +35% | 1% |
| от 0,06 до 0,10 | 300 | 100,0% | +13% | от -3% до +32% | 0% |
| от 0,10 до 0,20 | 300 | 100,0% | +11% | от -3% до +28% | 0% |
| от 0,20 до 0,45 | 300 | 97,7% | -11% | от -57% до +11% | 7% |
Знак определен верно в каждом окне при скорости изменения частоты до 0,20 цикла на бар и в 98% окон при более высокой скорости. Оценка величины имеет систематическое смещение: она завышена примерно на 11–13% при значениях ниже 0,20 и занижена примерно на 11% при значениях выше 0,20, поэтому единым масштабным коэффициентом это смещение не устранить. Это окна с одним чирп-сигналом — самый простой случай, поэтому таблицу следует рассматривать как результаты для наилучших условий.
Шум. Тот же тест с истинными скоростями изменения частоты от 0,10 до 0,40 при увеличении уровня шума:
| Стандартное отклонение шума | Отношение сигнал/шум, дБ | Окна | Совпадение знаков | Медиана относительной погрешности |
|---|---|---|---|---|
| 0,10 | 24,6 | 300 | 100,0% | 8% |
| 0,25 | 16,6 | 300 | 99,7% | 8% |
| 0,50 | 10,6 | 300 | 99,3% | 9% |
| 1,00 | 4,6 | 300 | 97,3% | 10% |
| 1,50 | 1,1 | 300 | 93,7% | 12% |
| 2,50 | -3,4 | 300 | 81,7% | 34% |
Доля совпадения знаков остается выше 97% при снижении отношения сигнал/шум примерно до 5 дБ и падает до 82% при −3,4 дБ. Для окон реальных рыночных данных отношение сигнал/шум не определено, поэтому этот тест показывает, при каких условиях качество оценки резко падает, а не каких результатов следует ожидать на конкретном торговом инструменте.
Окно и диапазон. Для каждой ячейки использовано 200 тестовых чирп-сигналов с истинными скоростями изменения частоты от 0,10 до 0,40; приведены доля совпадения знаков и медиана относительной погрешности:
| Окно | Диапазон от 0,50 до 1,50 | Диапазон от 0,60 до 1,40 | Диапазон от 0,70 до 1,30 |
|---|---|---|---|
| 32 | 100,0%, 14% | 99,5%, 14% | 99,5%, 14% |
| 48 | 100,0%, 11% | 100,0%, 11% | 99,0%, 11% |
| 64 | 100,0%, 10% | 100,0%, 10% | 99,5%, 10% |
| 96 | 100,0%, 6% | 100,0%, 7% | 99,5%, 6% |
| 128 | 100,0%, 5% | 100,0%, 5% | 100,0%, 5% |
Выбор диапазона почти не влияет на результаты. Большее значение имеет длина окна: медиана погрешности снижается примерно с 14% при длине 32 бара до 5% при длине 128 баров. В разделе 8 варьируется ширина полосы, а тип энтропии и способ удаления тренда остаются неизменными.
Отслеживание меняющейся скорости изменения частоты. Я сгенерировал циклы с синусоидально меняющейся частотой и сравнил μ̂ с истинной скоростью изменения частоты в центре каждого окна (четыре начальных значения генератора случайных чисел, по 1 200 баров для каждого), разбив результаты по совпадению знаков на группы в зависимости от отношения истинной скорости к ее пиковому значению:
| Размах колебаний | Пиковая истинная скорость изменения частоты | Корреляция с истинной скоростью изменения частоты | Все бары | Истинная скорость изменения частоты ниже 25% от пиковой | от 25 до 50% | 50% и более |
|---|---|---|---|---|---|---|
| Умеренный | 0,030 | 0,946 | 94,8% | 70,4% | 97,4% | 100,0% |
| Сильный | 0,071 | 0,973 | 96,5% | 82,4% | 98,2% | 100,0% |
| Очень сильный | 0,134 | 0,883 | 81,2% | 67,2% | 53,5% | 92,2% |

Рис. 4. Оценка скорости изменения частоты (синий цвет) в сравнении с истинной скоростью в центре каждого окна (серый цвет) для сильных колебаний частоты на протяжении 520 баров. Оценка отслеживает смены знака. Вертикальные выбросы соответствуют барам, на которых поиск перескочил к другому минимуму.
Оценка отслеживает изменения, а ее знак, как и ожидалось, наименее устойчив при скорости изменения частоты, близкой к нулю. При самом сильном колебании частоты качество оценки ухудшается во всех диапазонах, хотя пиковая скорость изменения частоты (0,134) значительно ниже предельного значения 0,727, доступного поиску, так что причина не в насыщении. Более вероятная причина заключается в том, что частота меняется слишком сильно в пределах одного окна, чтобы чирп-сигнал оставался линейным. На рис. 4 также видны выбросы — отдельные бары, на которых поиск перескакивает к вторичному минимуму. На реальных ценах закрытия оценка меняет знак примерно на каждом десятом баре (10% баров), как и при случайном блуждании, по сравнению с 1,7% при сильных синтетических колебаниях частоты; скачки более 0,30 редки (0,35% баров).
Сигналы, не являющиеся чирп-сигналами. Энтропия снижается всякий раз, когда энергия концентрируется, а чирп-сигнал — лишь один из способов такой концентрации, поэтому я применил тот же метод оценки к другим структурам (по 300 окон для каждой):
| Окно | Медиана |μ̂| | Доля случаев с |μ̂| выше 0,10 | Медианный выигрыш в концентрации, нат |
|---|---|---|---|
| Тон постоянной частоты | 0,002 | 0% | 0,001 |
| Тональный импульс с гауссовой огибающей | 0,019 | 1% | 0,006 |
| Импульс в шуме | 0,229 | 79% | 0,104 |
| Прямоугольный сигнал | 0,004 | 0% | 0,003 |
| Шум AR(1), φ = 0,9 | 0,029 | 13% | 0,068 |
| Случайное блуждание | 0,023 | 10% | 0,061 |
| Скачок частоты (не линейное изменение) | 0,164 | 86% | 0,786 |
| ЛЧМ-сигнал, |c| = 0,25 | 0,256 | 100% | 1,468 |
Для тональных и прямоугольных сигналов оценка μ̂ близка к нулю, а для импульса она велика, но выигрыш в концентрации мал, поэтому импульс помечается флагом. Особого внимания заслуживает скачок частоты: оценка μ̂ для него велика, медианный выигрыш в концентрации составляет 0,79, что значительно выше порога, а знак оценки совпадает с направлением скачка в 99% окон. Он выглядит как чирп-сигнал и не помечается флагом. По сути, μ̂ отражает направление изменения доминирующей частоты внутри окна независимо от того, линейно это изменение или нет.
Проверка реализации на MQL5. FrFT_SelfTest воспроизводит проверки тождеств и тесты с четырьмя эталонными чирп-сигналами через ту же функцию CalcBar, которую использует индикатор, затем выполняет тест на воспроизводимом случайном блуждании и замер времени выполнения, что позволяет сравнить вычислительную реализацию на MQL5 с ее аналогом на Python. Приведенные ниже значения должны совпадать с точностью до четырех знаков после запятой:
FrFT_SelfTest: OnStart
//+------------------------------------------------------------------+ //| OnStart | //| Prints engine identities, known-chirp readings and timing. | //| Compare against the reference table in the article. | //+------------------------------------------------------------------+ void OnStart() { CFrFTEngine eng; ulong t0=GetMicrosecondCount(); if(!eng.Init(ST_N)) { Print("FrFT_SelfTest: engine init failed"); return; } PrintFormat("init %d: %.1f ms",ST_N,(GetMicrosecondCount()-t0)/1000.0); //--- identities on a fixed complex vector double xr[],xi[],yr[],yi[],ur[],ui[],vr[],vi[]; ArrayResize(xr,ST_N); ArrayResize(xi,ST_N); ArrayResize(yr,ST_N); ArrayResize(yi,ST_N); ArrayResize(ur,ST_N); ArrayResize(ui,ST_N); ArrayResize(vr,ST_N); ArrayResize(vi,ST_N); double nx=0.0; for(int j=0;j<ST_N;j++) { xr[j]=MathSin(0.37*j+0.1)+0.5*MathCos(1.3*j); xi[j]=MathCos(0.21*j)-0.3*MathSin(2.1*j); nx+=xr[j]*xr[j]+xi[j]*xi[j]; } eng.Project(xr,xi,yr,yi); eng.Rotate(yr,yi,1.0,ur,ui); double e_dft=0.0; for(int k=0;k<ST_N;k++) { double re=0.0,im=0.0; for(int j=0;j<ST_N;j++) { double th=2.0*M_PI*j*k/ST_N; re+=xr[j]*MathCos(th)+xi[j]*MathSin(th); im+=xi[j]*MathCos(th)-xr[j]*MathSin(th); } re/=MathSqrt((double)ST_N); im/=MathSqrt((double)ST_N); e_dft=MathMax(e_dft,MathMax(MathAbs(ur[k]-re),MathAbs(ui[k]-im))); } eng.Rotate(yr,yi,0.77,ur,ui); double ny=0.0; for(int j=0;j<ST_N;j++) ny+=ur[j]*ur[j]+ui[j]*ui[j]; eng.Project(ur,ui,vr,vi); eng.Rotate(vr,vi,-0.77,ur,ui); double e_inv=0.0; for(int j=0;j<ST_N;j++) e_inv=MathMax(e_inv,MathMax(MathAbs(ur[j]-xr[j]),MathAbs(ui[j]-xi[j]))); PrintFormat("a=1 vs DFT max err %.2e",e_dft); PrintFormat("norm drift at a=0.77 %.2e",MathAbs(MathSqrt(ny)-MathSqrt(nx))); PrintFormat("inverse max err %.2e",e_inv); //--- known chirps: mu_hat should land near c, sign must match double cs[4]; cs[0]=-0.40; cs[1]=-0.25; cs[2]=0.25; cs[3]=0.40; double win[]; ArrayResize(win,ST_N); for(int t=0;t<4;t++) { for(int j=0;j<ST_N;j++) { double kk=j-ST_N/2; win[j]=2000.0+0.014*j+2.4*MathCos(2.0*M_PI*(0.12*kk+cs[t]*kk*kk/(2.0*ST_N))); } double cyc,a_star,gain; eng.CalcBar(win,FRFT_DEFAULT_AMIN,FRFT_DEFAULT_AMAX,FRFT_DEFAULT_GSS_TOL, FRFT_DEFAULT_GSS_ITER,ST_BAND,cyc,a_star,gain); double mu=-1.0/MathTan(a_star*M_PI/2.0); PrintFormat("c=%+.2f a*=%.4f mu=%+.4f cycle=%.4f gain=%.4f",cs[t],a_star,mu,cyc,gain); } //--- deterministic random walk: last-window result and time per bar long seed=12345; double px[]; double p=2000.0; int total=ST_N+200; ArrayResize(px,total); for(int i=0;i<total;i++) { seed=(seed*1103515245+12345)&0x7fffffff; p+=(double)seed/2147483648.0-0.5; px[i]=p; } double cyc=0.0,a_star=0.0,gain=0.0; t0=GetMicrosecondCount(); for(int i=ST_N-1;i<total;i++) { ArrayCopy(win,px,0,i-ST_N+1,ST_N); eng.CalcBar(win,FRFT_DEFAULT_AMIN,FRFT_DEFAULT_AMAX,FRFT_DEFAULT_GSS_TOL, FRFT_DEFAULT_GSS_ITER,ST_BAND,cyc,a_star,gain); } double us=(double)(GetMicrosecondCount()-t0)/(double)(total-ST_N+1); PrintFormat("walk last bar: a*=%.4f cycle=%.4f gain=%.4f",a_star,cyc,gain); PrintFormat("%.1f us per bar over %d bars",us,total-ST_N+1); }
| Истинное c | a* | μ̂ | Значение цикла | Выигрыш в концентрации, нат |
|---|---|---|---|---|
| -0,40 | 0,7714 | -0,3754 | 2002,5588 | 1,3977 |
| -0,25 | 0,8373 | -0,2612 | 2001,2784 | 1,7119 |
| +0,25 | 1,1636 | +0,2628 | 2000,8487 | 1,7209 |
| +0,40 | 1,2271 | +0,3727 | 1999,5256 | 1,6256 |
| Случайное блуждание, последний бар | 1,0017 | 2002,2528 | 0,0011 |
На моем настольном компьютере в ходе двух прогонов было зафиксировано время 339 и 363 мкс на один бар для 201 бара, так что первый расчет для 2 000 баров занимает менее секунды.
Реальные цены для разных торговых инструментов и таймфреймов
Синтетические сигналы подтверждают правильность преобразования, а не индикатора, поэтому в последнем тесте используются реальные цены закрытия. FrFT_ExportCloses записывает цены закрытия для списка торговых инструментов и таймфреймов в каталог MQL5\Files\FrFT_ChirpCycle, повторяя запросы исторических данных, которые терминал, возможно, еще загружает, а скрипты Python считывают эти данные с помощью параметра --csv-dir.
FrFT_ExportCloses: ParseTf
//+------------------------------------------------------------------+ //| ParseTf | //| Timeframe name to enum. PERIOD_CURRENT means unknown. | //+------------------------------------------------------------------+ ENUM_TIMEFRAMES ParseTf(const string s) { if(s=="M5") return(PERIOD_M5); if(s=="M15") return(PERIOD_M15); if(s=="M30") return(PERIOD_M30); if(s=="H1") return(PERIOD_H1); if(s=="H4") return(PERIOD_H4); if(s=="D1") return(PERIOD_D1); return(PERIOD_CURRENT); }
FrFT_ExportCloses: OnStart
//+------------------------------------------------------------------+ //| OnStart | //| Writes time,close of the last InpBars closed bars for every | //| symbol and timeframe pair to | //| MQL5\Files\FrFT_ChirpCycle\closes_SYMBOL_TF.csv (oldest first). | //+------------------------------------------------------------------+ void OnStart() { string sym[],tfs[]; int ns=StringSplit(InpSymbols,',',sym); int nt=StringSplit(InpTimeframes,',',tfs); FolderCreate("FrFT_ChirpCycle"); for(int i=0;i<ns;i++) { StringTrimLeft(sym[i]); StringTrimRight(sym[i]); if(!SymbolSelect(sym[i],true)) { Print("FrFT_ExportCloses: unknown symbol ",sym[i]); continue; } for(int j=0;j<nt;j++) { StringTrimLeft(tfs[j]); StringTrimRight(tfs[j]); ENUM_TIMEFRAMES tf=ParseTf(tfs[j]); if(tf==PERIOD_CURRENT) { Print("FrFT_ExportCloses: unknown timeframe ",tfs[j]); continue; } double cl[]; datetime tm[]; ArraySetAsSeries(cl,false); ArraySetAsSeries(tm,false); int n=-1; //--- first request may only trigger a history download; retry a few times for(int tries=0;tries<3 && n<=0;tries++) { n=CopyClose(sym[i],tf,1,InpBars,cl); if(n<=0) Sleep(1000); } if(n<=0 || CopyTime(sym[i],tf,1,InpBars,tm)!=n) { Print("FrFT_ExportCloses: no data for ",sym[i]," ",tfs[j]); continue; } string path="FrFT_ChirpCycle\\closes_"+sym[i]+"_"+tfs[j]+".csv"; int h=FileOpen(path,FILE_WRITE|FILE_CSV|FILE_ANSI,','); if(h==INVALID_HANDLE) { Print("FrFT_ExportCloses: cannot open ",path,", code ",GetLastError()); continue; } FileWrite(h,"time","close"); int digits=(int)SymbolInfoInteger(sym[i],SYMBOL_DIGITS); for(int k=0;k<n;k++) FileWrite(h,TimeToString(tm[k],TIME_DATE|TIME_MINUTES),DoubleToString(cl[k],digits)); FileClose(h); PrintFormat("FrFT_ExportCloses: %d bars -> MQL5\\Files\\%s",n,path); } } }
Для реальных цен нет известного истинного значения скорости изменения частоты, поэтому тест проверяет то, что можно установить по данным. Возьмем два последовательных непересекающихся окна по 64 бара — A и B. Доминирующая частота в каждом окне определяется по положению пика спектра цен закрытия после удаления тренда и применения окна Ханна. Положение пика уточняется с помощью параболической аппроксимации. Индикатор использует только данные окна A и выдает оценку μ̂; если она положительна, доминирующая частота в окне B должна быть выше, чем в окне A. Прогноз считается верным, если знак μ̂ совпадает со знаком f B − f A. Случаи равенства исключаются, базовый уровень составляет 50%, а для каждой доли верных прогнозов приводится 95%-ный интервал Уилсона. Целевая величина служит косвенным показателем, поскольку f B сама по себе является зашумленной оценкой. Используются последние 6000 закрытых баров для каждого сочетания торгового инструмента и таймфрейма с демо-сервера MetaQuotes (EURUSD, GBPUSD и USDJPY на M15, H1 и H4, XAUUSD на M15 и H1); параметры оставлены по умолчанию, без подстройки под эти данные.
| Обозначение | Таймфрейм | Бары | Окна | Доля верных прогнозов | 95%-й доверительный интервал | a* на границе диапазона |
|---|---|---|---|---|---|---|
| EURUSD | H1 | 6000 | 91 | 57,1% | от 46,9 до 66,8% | 0% |
| EURUSD | H4 | 6000 | 91 | 53,8% | от 43,7 до 63,7% | 0% |
| EURUSD | M15 | 6000 | 91 | 47,3% | от 37,3 до 57,4% | 0% |
| GBPUSD | H1 | 6000 | 91 | 53,8% | от 43,7 до 63,7% | 0% |
| GBPUSD | H4 | 6000 | 91 | 58,2% | от 48,0 до 67,8% | 0% |
| GBPUSD | M15 | 6000 | 91 | 58,2% | от 48,0 до 67,8% | 0% |
| USDJPY | H1 | 6000 | 91 | 48,4% | от 38,4 до 58,5% | 0% |
| USDJPY | H4 | 6000 | 91 | 47,3% | от 37,3 до 57,4% | 0% |
| USDJPY | M15 | 6000 | 91 | 49,5% | от 39,4 до 59,5% | 0% |
| XAUUSD | H1 | 6000 | 91 | 49,5% | от 39,4 до 59,5% | 0% |
| XAUUSD | M15 | 6000 | 91 | 37,4% | от 28,1 до 47,6% | 0% |
| Объединенные данные | 1001 | 50,9% | от 47,9 до 54,0% | 0% |

Рис. 5. Доля верных прогнозов направления по торговым инструментам и таймфреймам с 95%-ными доверительными интервалами. Пунктирная линия соответствует 50% — вероятности случайного угадывания при броске монеты, а закрашенная полоса обозначает доверительный интервал для объединенных данных.
По объединенным данным для 1001 окна знак оценки совпадает со знаком изменения частоты в следующем окне в 50,9% случаев (95%-ный доверительный интервал — от 47,9 до 54,0%); этот интервал включает 50%, то есть измеримая прогностическая информация отсутствует. Ни у одной пары доверительный интервал не лежит целиком выше 50%, а столбец "Граница диапазона" показывает лишь, что отсечения не было. При примерно 90 окнах на каждое сочетание инструмента и таймфрейма границы интервала находятся примерно в 10 процентных пунктах от оценки, поэтому небольшой эффект остался бы незаметным, а объединенный интервал дает несколько излишне оптимистичную оценку точности, поскольку данные разных таймфреймов одного торгового инструмента перекрываются, а валютные пары имеют общие валюты. Здесь проверяется, несет ли показание индикатора какую-либо информацию о ритме следующего окна, а не то, будет ли сделка прибыльной.
Обнаружил бы тест эффект? Я провел ту же процедуру на синтетических рядах:
| Ряд | Окна | Доля верных прогнозов | 95%-й доверительный интервал |
|---|---|---|---|
| Положительный контроль: медленные колебания | 455 | 67,0% | от 62,6 до 71,2% |
| Положительный контроль: быстрые колебания | 455 | 70,1% | от 65,7 до 74,1% |
| Отрицательный контроль: случайное блуждание | 1001 | 50,0% | от 47,0 до 53,1% |
| Отрицательный контроль: бутстреп реальных доходностей | 1001 | 49,2% | от 46,1 до 52,2% |
Доля верных прогнозов для устойчивых синтетических колебаний составляет 67,0% и 70,1%, для случайного блуждания — 50,0%, а для бутстрепа реальных доходностей — 49,2%. Таким образом, процедура выявляет действительно существующий эффект, а результат на реальных данных, равный 50,9%, находится на уровне отрицательных контролей.
Настройки и выборка. Изменение окна, диапазона поиска, периода или подмножества данных:
| Вариант | Окна | Доля верных прогнозов | 95%-й доверительный интервал |
|---|---|---|---|
| Окно 32, диапазон от 0,6 до 1,4 | 2035 | 48,8% | от 46,6 до 51,0% |
| Окно 64, диапазон от 0,6 до 1,4 | 1001 | 50,9% | от 47,9 до 54,0% |
| Окно 128, диапазон от 0,6 до 1,4 | 484 | 53,1% | от 48,6 до 57,5% |
| Окно 64, диапазон от 0,7 до 1,3 | 1001 | 50,5% | от 47,5 до 53,6% |
| Окно 64, диапазон от 0,5 до 1,5 | 1001 | 51,4% | от 48,4 до 54,5% |
| Первая половина | 484 | 50,4% | от 46,0 до 54,8% |
| Вторая половина | 517 | 51,5% | от 47,1 до 55,7% |
| Таймфрейм M15 | 364 | 48,1% | от 43,0 до 53,2% |
| Таймфрейм H1 | 364 | 52,2% | от 47,1 до 57,3% |
| Таймфрейм H4 | 273 | 53,1% | от 47,2 до 58,9% |
| EURUSD | 273 | 52,7% | от 46,8 до 58,6% |
| GBPUSD | 273 | 56,8% | от 50,8 до 62,5% |
| USDJPY | 273 | 48,4% | от 42,5 до 54,3% |
| XAUUSD | 182 | 43,4% | от 36,4 до 50,7% |
Общая доля верных прогнозов остается около 50% для окон длиной 32, 64 и 128 баров, двух других диапазонов порядка, обеих половин исторических данных, а также для всех таймфреймов и торговых инструментов. Только у GBPUSD интервал целиком лежит выше 50% (от 50,8 до 62,5%), что вполне объяснимо случайностью при рассмотрении семи интервалов для подгрупп. Все эти результаты получены на одном наборе данных из потока котировок демосчета одного брокера. Данные других брокеров и за другие периоды не проверялись.
Еще две проверки приводят к тому же выводу. Знак μ̂ совпадает со знаком изменения частоты между двумя половинами того же окна в 55,6% случаев на реальных ценах закрытия, но в 53,8% случаев на бутстреп-данных без структуры (и в 100% случаев на известных чирп-сигналах), поэтому окна реальных данных демонстрируют не больше признаков структуры чирп-сигнала, чем перемешанные доходности. Выигрыш в концентрации также не помогает в качестве фильтра: для окон со значением выше 0,40 доля верных прогнозов составляет 44,2% (52 окна), а для окон со значением ниже этого порога — 51,3%.
Пограничные случаи и возможные проблемы
Замена двумерного распределения на одномерный поиск не устраняет необходимость настройки. Ниже перечислены параметры, которые по-прежнему требуют выбора, и показатели, измеренные для каждого из них:
| Выбор | По умолчанию | Что измерялось |
|---|---|---|
| Длина окна | 64 бара | Совпадение знаков и погрешность при длине окна от 32 до 128 баров на синтетических чирп-сигналах (раздел 10). Доля верных прогнозов для следующего окна при длине окна 32, 64 и 128 баров на реальных ценах закрытия (раздел 11) |
| Диапазон порядка | от 0,60 до 1,40 | Диапазоны от 0,50 до 1,50 и от 0,70 до 1,30 дают такое же совпадение знаков и различие в погрешности не более одного пункта (раздел 10); ту же долю верных прогнозов на реальных данных (раздел 11) |
| Сохраняемая полоса | 0,08 | Сравнение с фиксированным порядком при четырех значениях ширины полосы (раздел 8); преимущество адаптивного подхода проявляется только при узких полосах |
| Удаление тренда | Линейное, всегда включено | Не варьировалось |
| Аналитический сигнал | Вкл. | Необходим: без него знак определяется как при подбрасывании монеты (раздел 4) |
| Энтропия | Энтропия Реньи второго порядка | Не варьировалось |
| Один доминирующий чирп-сигнал | Предполагается | В окнах с двумя чирп-сигналами поиск дает сбой примерно в 30% случаев, но эти окна все равно проходят проверку по выигрышу в концентрации; скачок частоты также проходит эту проверку (разделы 7 и 10) |
| Порог выигрыша в концентрации | 0,40 нат при n = 64 | Порог откалиброван по нулевой модели случайного блуждания; на реальных данных он превышается в 5% окон. Перекалибровать для других окон |
Окна с несколькими чирп-сигналами. При наличии двух конкурирующих минимумов поиск выбирает тот, которого первым достигают пробные точки, поэтому на короткой последовательности баров оценка скачет между двумя значениями, а флаг выигрыша в концентрации не выделяет такие окна. Уменьшение длины окна снижает частоту таких случаев, но делает оценку более шумной.
Окна без чирп-сигнала. Поиск все равно возвращает порядок, поэтому бар становится серым, когда выигрыш в концентрации ниже порога. На реальных ценах закрытия при длине окна по умолчанию около 95% баров окрашены в серый цвет, а тест в разделе 11 не выявил признаков того, что зеленые и красные бары несут какую-либо информацию о последующих данных.
Край окна. Линия цикла — это результат восстановления на самом новом баре, где любая оценка, ограниченная по полосе частот, наименее точна. При сохраняемой полосе по умолчанию коэффициент корреляции линии с истинным циклом составляет около 0,7, при этом я не отделял краевой эффект от шума.
Ускорение, а не направление. Зеленый столбец означает, что доминирующий цикл ускоряется, а не то, что цена растет.
Окно и запуск. Вычислительный модуль проверен для окон четной длины от 16 до 128 отсчетов; линия и гистограмма не определены для первых InpWindow − 1 баров, а входные параметры FrFT_ChirpRate должны совпадать с параметрами экземпляра, из которого он считывает данные.
Заключение
Оценка скорости изменения частоты с помощью FrFT работает как средство измерения на окнах с контролируемыми характеристиками. В окнах с одним доминирующим чирп-сигналом, частота которого изменяется приблизительно линейно, знак оценки верен почти всегда. Величина оценки имеет систематическое смещение примерно на 11–13%, направление которого зависит от значения скорости изменения частоты, а для цикла с колеблющейся частотой коэффициент корреляции показаний с истинной скоростью изменения частоты составляет от 0,883 до 0,973. Принципиальны две детали реализации: унитарное дискретное преобразование, построенное на основе собственных векторов, подобных функциям Эрмита, и аналитический сигнал, позволяющий определить знак. Унитарность обеспечивает корректное сравнение разных порядков преобразования, а результаты измерений подтверждают правильность показаний.
Ограничения столь же ясны. Линия цикла превосходит восстановление с выделением полосы в обычном спектре Фурье лишь при малой ширине полосы. Поиск ненадежен в окнах с двумя чирп-сигналами, причем флаг концентрации не выявляет эту проблему, а скачок частоты интерпретируется как чирп-сигнал. На реальных ценах закрытия прогностической информации не обнаружено: по 11 комбинациям и 1001 окну совпадение знаков наблюдалось в 50,9% случаев (интервал от 47,9 до 54,0%), тогда как та же процедура на синтетических рядах с сохраняющейся динамикой дала от 67 до 70%. Другие брокеры и периоды не тестировались. Рассматривайте индикатор как средство описательного измерения текущего окна, а не как торговый сигнал, и проведите проверку его прогностической способности на собственных рядах цен закрытия, прежде чем использовать его показания в каких-либо расчетах или решениях.
Прилагаемые файлы
| Файл | Расположение в архиве MQL5.zip | Описание |
|---|---|---|
| FrFT_Engine.mqh | MQL5\Include\FrFT_ChirpCycle | Модуль унитарного FrFT на основе собственных векторов: метод Якоби, построение базиса, Project/Rotate, аналитический сигнал, энтропия Реньи, поиск методом золотого сечения, восстановление по полосе, удаление тренда, CalcBar |
| FrFT_ChirpCycle.mq5 | MQL5\Indicators\FrFT_ChirpCycle | Отображает восстановленную линию цикла и предоставляет значения a* и выигрыша в концентрации через расчетные буферы |
| FrFT_ChirpRate.mq5 | MQL5\Indicators\FrFT_ChirpCycle | Считывает a* и выигрыш в концентрации через iCustom и строит гистограмму скорости изменения частоты |
| FrFT_SelfTest.mq5 | MQL5\Scripts\FrFT_ChirpCycle | Проверка тождеств вычислительного модуля, четырех чирп-сигналов с известными параметрами и детерминированного случайного блуждания с замером времени вычислений на каждом баре — для сравнения с эталонной реализацией на Python |
| FrFT_ExportCloses.mq5 | MQL5\Scripts\FrFT_ChirpCycle | Записывает цены закрытия для заданного списка торговых инструментов и таймфреймов в CSV для скриптов на Python (--csv-dir) |
| frft_chirp_validation.py | MQL5\Files\FrFT_ChirpCycle | Повторяет реализацию вычислительного модуля; выполняет основные тесты и проверку прогностической способности на реальных ценовых данных с фиксированными начальными значениями генераторов случайных чисел и создает рисунки |
| frft_review_tests.py | MQL5\Files\FrFT_ChirpCycle | Систематическое смещение, шум, чувствительность к окну и диапазону, контрольные тесты, выигрыш в концентрации, структуры, не являющиеся чирп-сигналами, подсчет выбросов, проверки хвостовых векторов и циклического переноса полосы через границу массива (python frft_review_tests.py PART --csv-dir DIR) |
| MQL5.zip | Архив, содержащий все перечисленные выше файлы. Распакуйте его в папку данных терминала, и каждый файл окажется в нужном месте. |
Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/24145
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.