Полиномиальная регрессия в реальном времени: Реализация каузального фильтра Савицкого — Голея на MQL5
Введение
Каждый трейдер, который когда-либо использовал скользящую среднюю, сталкивался с одной и той же проблемой: к моменту, когда она подтверждает разворот тренда, значительная часть движения уже позади. Это не недостаток какой-либо конкретной скользящей средней, а прямое следствие самого принципа усреднения. Скользящая средняя объединяет недавние и более старые цены, и, когда рынок разворачивается, эти старые цены еще несколько баров продолжают тянуть среднюю в неверном направлении. Это отставание показаний скользящей средней от движения цены трейдеры называют запаздыванием.
В данной статье представлен иной подход: фильтр Савицкого — Голея. Вместо усреднения исходных цен он аппроксимирует цены в окне последних наблюдений полиномом невысокой степени и использует полученную кривую для оценки текущего сглаженного значения. Полиномиальная аппроксимация позволяет отразить кривизну — ранние признаки разворота, — чего не позволяет обычное усреднение.
Сам по себе фильтр не является новинкой. Описание фильтра было опубликовано в 1964 году Абрахамом Савицким и Марселем Голеем, и с тех пор он стал стандартным средством сглаживания зашумленных показаний приборов в аналитической химии и спектроскопии. В торговле этот фильтр почти не применялся по конкретной технической причине: его классическая версия некаузальна — она использует данные как до, так и после сглаживаемой точки. В лабораторных условиях, где уже имеется полный набор данных, это вполне подходит. В реальной торговле это делает фильтр непригодным, поскольку сегодня еще неизвестна завтрашняя цена закрытия.
В статье подробно рассматривается каузальная адаптация: версия фильтра, которая использует только текущий бар и предшествующие ему бары, что позволяет применять ее в реальном времени точно так же, как скользящую среднюю. Мы приводим математический вывод и реализуем метод на MQL5 в виде индикатора и советника. Мы также рассматриваем следующий компромисс: более быстрая реакция на изменения тренда повышает чувствительность к шумовым колебаниям отдельного бара. Мы измерили этот эффект напрямую и показываем, какой именно защитный механизм использует прилагаемый советник, чтобы ограничить его влияние.
На практике адаптация фильтра Савицкого — Голея для реальной торговли сопряжена с тремя конкретными проблемами:
- Будущие данные недоступны. Преимущество классического фильтра обусловлено использованием баров как до, так и после сглаживаемой точки. Однако в реальной торговле доступны только прошлые и текущие бары, что вынуждает применять принципиально иной вариант того же математического подхода — с вычислением в конечной точке окна.
- Вычисление на краю окна повышает чувствительность к шуму. Вычисление значения полиномиальной аппроксимации на краю окна, а не в его центре, заставляет фильтр в большей степени опираться на самый последний бар, что уменьшает запаздывание, но при этом действительно усиливает влияние одиночного шумового колебания цены на результат.
- Универсальной длины окна не существует. Подходящие длины окон быстрого и медленного фильтров зависят от торгового инструмента, таймфрейма и типичной продолжительности тренда на графике. Рассматривайте любые настройки как проверенную отправную точку, а не как правило.
Все три аспекта подробно рассматриваются в статье. Каузальный вариант фильтра выводится из базовых принципов. Компромисс между быстротой реакции и чувствительностью к шуму измеряется напрямую, а не замалчивается. И показывается конкретный защитный механизм, который прилагаемый советник использует для учета этого компромисса на практике.
Идея 1: почему усреднение вызывает запаздывание, а аппроксимация данных кривой его уменьшает
Простая скользящая средняя с математической точки зрения представляет собой полиномиальную аппроксимацию нулевой степени: она приближает последние N цен горизонтальной прямой и выдает ее уровень. Это работает, когда цена действительно остается примерно на одном уровне. Такая модель не позволяет описать искривление ценовой траектории — ускорение движения или замедление перед разворотом, — поскольку у горизонтальной прямой вообще нет параметра, отражающего кривизну.
Фильтр Савицкого — Голея вместо этого аппроксимирует данные в том же окне полиномом более высокой степени, обычно второй. Квадратичная кривая может характеризоваться уровнем, наклоном и кривизной — она может изгибаться. Когда цена действительно начинает менять направление, квадратичная аппроксимация последних нескольких баров может выявить эту кривизну раньше, чем простая скользящая средняя, просто потому, что у горизонтальной модели нет средств отразить разворот, пока он не станет преобладать в окне. Однако у этой чувствительности есть и обратная сторона: квадратичная аппроксимация может с такой же легкостью рано уловить случайный изгиб, вызванный шумом, и выдать его за разворот; именно поэтому и нужен защитный механизм подтверждения, рассматриваемый далее в статье.
Degree 0 fit (Simple Moving Average): price(t) ≈ a0 Degree 2 fit (Savitzky-Golay, quadratic): price(t) ≈ a0 + a1*t + a2*t^2
Коэффициенты a0, a1, a2 определяются с помощью регрессии методом обычных наименьших квадратов по данным выбранного окна. После построения аппроксимации значение фильтра на текущем баре просто равно значению этой кривой в точке, соответствующей данному бару.
Идея 2: как сделать фильтр каузальным — аппроксимация только по прошлым данным
В классическом варианте фильтра Савицкого — Голея полином аппроксимирует данные в симметричном окне — точки как до, так и после сглаживаемого бара. Именно эта симметрия обеспечивает классическому фильтру эффективное подавление шума при обработке данных в офлайн-режиме, когда весь набор данных уже известен.
В реальной торговле такой роскоши нет. При расчете значения индикатора для текущего бара будущих баров еще нет. В предлагаемом варианте тот же полином 2-й степени аппроксимирует данные в окне, состоящем только из текущего бара и фиксированного числа предыдущих баров, а значение полученной кривой вычисляется в самой последней точке этого окна, а не в его центре.
Non-causal (textbook) window, size 9, evaluated at the CENTER: [ -4 -3 -2 -1 (0) +1 +2 +3 +4 ] <- evaluated here Causal (this article's) window, size 9, evaluated at the END: [ -8 -7 -6 -5 -4 -3 -2 -1 (0) ] <- evaluated here
Поскольку коэффициенты фильтра зависят только от размера окна и степени полинома, но не от фактических цен, их можно вычислить один раз и затем использовать как фиксированный набор весов — точно так же, как веса простой скользящей средней (по 1/N каждый) не требуют пересчета. Веса каузального фильтра Савицкого — Голея подчиняются тому же принципу; просто они не одинаковы.
Идея 3: Реальный компромисс — меньшее запаздывание означает большую чувствительность к последнему бару
Эту особенность поведения фильтра обычно не обсуждают, но мы хотим сказать о ней прямо, а не обходить ее молчанием.
Поскольку значение каузального фильтра вычисляется на краю окна, а не в его центре, получаемая оценка является краевой, а не центрированной. При этом сама точка вычисления по-прежнему находится при x=0, внутри окна данных. Таким образом, это не экстраполяция в строгом смысле — не оценка за пределами диапазона наблюдений. При центрированной аппроксимации данные ограничивают форму кривой с обеих сторон. При вычислении на краю окна — только с одной стороны, причем направление кривой в большей степени определяется точками, ближайшими к этому краю, то есть самыми последними барами.
Когда мы рассчитали коэффициенты каузального квадратичного фильтра с окном длиной 9 баров, вес одного самого последнего бара оказался равен примерно 0,66, тогда как у простой скользящей средней с той же длиной окна, где все бары имеют одинаковый вес, он составляет около 0,11. Каузальный фильтр примерно в шесть раз сильнее зависит от последней точки данных.
Следствие очевидно: один бар с необычно высоким уровнем шума изменяет выходное значение этого фильтра заметно сильнее, чем значение скользящей средней той же длины. Такова цена уменьшения запаздывания, и эти два свойства взаимосвязаны: их нельзя выбирать независимо друг от друга — фильтр, который сильнее опирается на последние данные, чтобы реагировать быстрее, в силу того же свойства будет быстрее реагировать и на шум. Именно поэтому прилагаемый советник не реагирует на простое пересечение линий сразу же после его возникновения. Сначала советник требует, чтобы взаимное положение линий после пересечения сохранялось в течение заданного минимального числа последовательных закрытых баров. Это намеренно введенная и проверенная мера защиты именно от такой чувствительности, описанная ниже в разделе реализации.
Одно уточнение о том, что именно описывают свойства фильтра: более короткое окно или меньшая степень полинома изменяют реакцию линии фильтра на цену, но торговая система — понятие более широкое. Она также включает правило пересечения, задержку InpConfirmBars, логику переворота позиции, фиксированный размер лота и конкретный порядок обработки баров. Более быстрая реакция фильтра означает лишь то, что его выходная линия начинает двигаться раньше, — это само по себе не делает стратегию лучше, поскольку задержка подтверждения, асимметрия окна и отсутствие стоп-лосса совместно влияют на сигнал еще до открытия сделки. Результаты, приведенные в разделе "Тестирование на исторических данных", отражают работу всей системы, а не отдельно взятого фильтра.
Требования и настройка
Все, о чем идет речь в этой статье, работает в стандартной версии MetaTrader 5 без внешних библиотек и установки дополнительных компонентов. Коэффициенты фильтра вычисляются исключительно с помощью базовой линейной алгебры, реализованной непосредственно в MQL5, поэтому фильтр не зависит от Python, DLL или каких-либо сторонних численных библиотек.
Что вам понадобится:
- MetaTrader 5 с подключением к брокеру и доступом к торговому инструменту и таймфрейму, на которых вы планируете проводить тестирование
- MetaEditor (входит в состав MetaTrader 5) для компиляции индикатора и советника
- Достаточный объем загруженной истории цен по выбранному торговому инструменту — прежде чем фильтр выдаст первое значение, ему требуется период прогрева, о котором подробнее рассказано ниже
Этот проект состоит из двух файлов:
- Индикатор (.mq5), который отображает быструю и медленную линии Савицкого — Голея непосредственно на ценовом графике
- Советник (.mq5), который с помощью iCustom() создает собственный экземпляр индикатора, используя свои входные параметры InpFastWindow / InpSlowWindow / InpPolyOrder, и торгует по пересечениям линий этого экземпляра; в советник встроен механизм обеспечения устойчивости из Идеи 3. Добавление индикатора на тот же график с такими же настройками помогает визуально отслеживать, на что реагирует советник, однако сам советник считывает данные не из этого экземпляра. Вызов iCustom() создает собственный экземпляр вне зависимости от того, добавлен ли индикатор на график.
Индикатор должен быть скомпилирован и находиться в папке MQL5/Indicators до того, как советник будет прикреплен к графику, поскольку советник загружает его по имени при инициализации и не запустится, если не сможет его найти.
О периоде прогрева: поскольку окно медленного фильтра длиннее окна быстрого, для расчета первого значения индикатора требуется не меньше баров истории, чем составляет длина окна медленного фильтра. Если на графике загружено слишком мало исторических данных, обе линии просто не будут отображаться, пока не станет доступно достаточное количество баров. Это ожидаемое поведение, а не ошибка.
Индикатор: полный разбор кода
В этом разделе файл индикатора рассматривается от начала до конца. Рассмотрены все функциональные блоки. Без отдельных комментариев оставлены только закрывающие фигурные скобки и пустые строки, которые сами по себе не содержат логики.
1. Свойства и входные параметры:
#property indicator_chart_window #property indicator_buffers 2 #property indicator_plots 2 #property indicator_label1 "SG Fast" #property indicator_type1 DRAW_LINE #property indicator_color1 clrDodgerBlue #property indicator_style1 STYLE_SOLID #property indicator_width1 2 #property indicator_label2 "SG Slow" #property indicator_type2 DRAW_LINE #property indicator_color2 clrOrangeRed #property indicator_style2 STYLE_SOLID #property indicator_width2 2
Свойство indicator_chart_window размещает индикатор непосредственно на ценовом графике, а не в отдельном подокне, поскольку обе линии используют ту же ценовую шкалу, что и свечи. Это индикатор, накладываемый на ценовой график, как и скользящая средняя, а не осциллятор наподобие RSI. Объявляются два буфера и две отображаемые линии — быстрая и медленная. Каждой линии задаются собственные метка, цвет и стиль линии, чтобы их можно было различить с первого взгляда.
input int InpFastWindow = 50; // Fast Window Length (bars) input int InpSlowWindow = 100; // Slow Window Length (bars) input int InpPolyOrder = 2; // Polynomial Order (2 = quadratic; keep low for stability)
Эти три входных параметра — единственные, которые необходимо регулировать пользователю. Параметры InpFastWindow и InpSlowWindow задают количество баров в окне полиномиальной аппроксимации для каждой линии. InpPolyOrder задает степень полинома, которую следует оставлять равной 2 по соображениям устойчивости, рассмотренным в Идее 3: более высокая степень дает аппроксимации больше свободы для резких колебаний в точке на краю окна.
//--- Two overlay lines, plotted directly on the price chart like a pair //--- of moving averages — this is an overlay tool, not an oscillator. double BufFast[]; double BufSlow[]; //--- Precomputed filter coefficients. Since a causal Savitzky-Golay //--- filter's coefficients depend only on the window length and //--- polynomial order — never on the price data itself — they are //--- calculated once in OnInit() rather than recomputed on every bar. double FastCoefs[]; double SlowCoefs[];
BufFast и BufSlow — это индикаторные буферы, значения которых отображаются на графике. MetaTrader распознает их именно потому, что далее в OnInit() они регистрируются с помощью SetIndexBuffer(); их значения образуют две видимые линии. FastCoefs и SlowCoefs вовсе не являются буферами для отображения на графике — это обычные массивы, в которых хранятся заранее вычисленные веса фильтра для каждой линии. Они хранятся в виде обычных массивов, а не индикаторных буферов. Они не отображаются на графике, не требуют изменения размера по мере увеличения объема истории и не используются для доступа извне. Их регистрация в качестве буферов привела бы к ненужным накладным расходам.
2. Решатель линейных систем:
//+------------------------------------------------------------------+ //| Simple Gauss-Jordan solver for a small linear system. | //| Every array operation's return value is checked here, since a | //| silent allocation failure partway through would otherwise leave | //| this function operating on a partially-sized or partially-copied | //| array without any indication that something had gone wrong. | //+------------------------------------------------------------------+ bool SolveLinearSystem(double &Ain[], double &bIn[], int m, double &x[]) { //--- Allocate the local working copies first. ArrayResize() returns //--- the array's new size on success, or -1 if the allocation failed //--- (for example, if the terminal is genuinely out of memory) — that //--- failure is checked explicitly rather than assumed away. double A[]; double b[]; if(ArrayResize(A, m * m) < 0 || ArrayResize(b, m) < 0 || ArrayResize(x, m) < 0) { Print("SolveLinearSystem: ArrayResize failed, error code: ", GetLastError()); return false; } //--- ArrayCopy() returns the number of elements actually copied, or -1 //--- on failure. Checking this matters here specifically: if the copy //--- silently failed, A and b would be left as zero-filled arrays //--- rather than genuine copies of the caller's data, and every //--- calculation below would proceed on that wrong data without error. if(ArrayCopy(A, Ain) < 0 || ArrayCopy(b, bIn) < 0) { Print("SolveLinearSystem: ArrayCopy failed, error code: ", GetLastError()); return false; }
Эта функция решает небольшую систему линейных уравнений A * x = b с помощью метода Гаусса — Жордана. Каждое выделение памяти и копирование явно проверяется: функция ArrayResize() возвращает новый размер массива в случае успеха или -1 в случае ошибки, а функция ArrayCopy() возвращает количество скопированных элементов или -1 в случае ошибки — если бы эти значения игнорировались без предупреждения, функция могла бы продолжить работу с неполными или некорректными данными без каких-либо признаков того, что произошла ошибка.
for(int col = 0; col < m; col++) { //--- Partial pivoting for numerical stability int pivotRow = col; double maxVal = MathAbs(A[col * m + col]); for(int row = col + 1; row < m; row++) { if(MathAbs(A[row * m + col]) > maxVal) { maxVal = MathAbs(A[row * m + col]); pivotRow = row; } } if(maxVal < 1e-12) return false; // singular matrix — should not happen for valid inputs
Для каждого столбца выполняется поиск строки с наибольшим по модулю элементом в этом столбце, который выбирается в качестве ведущего элемента. Это частичный выбор главного элемента — стандартный прием повышения численной устойчивости. Без этого малый по модулю ведущий элемент может настолько усилить погрешности округления при вычислениях с плавающей запятой, что полученные коэффициенты будут существенно отличаться от верных. Если все кандидаты на роль ведущего элемента практически равны нулю, матрица вырождена и функция сообщает о неудаче.
if(pivotRow != col) { for(int k = 0; k < m; k++) { double tmp = A[col * m + k]; A[col * m + k] = A[pivotRow * m + k]; A[pivotRow * m + k] = tmp; } double tmpB = b[col]; b[col] = b[pivotRow]; b[pivotRow] = tmpB; }
Если выбранный ведущий элемент находится не в текущей строке, содержащую его строку меняют местами с текущей строкой матрицы A, одновременно переставляя соответствующие элементы вектора b, чтобы сохранить согласованность системы. Если пропустить эту перестановку, код может выполнить деление на очень малый по модулю ведущий элемент и усилить погрешности округления. Код при этом может продолжать работать, но возвращать существенно неверные коэффициенты, особенно для малых матриц.
double pivot = A[col * m + col]; for(int k = 0; k < m; k++) A[col * m + k] /= pivot; b[col] /= pivot; for(int row = 0; row < m; row++) { if(row == col) continue; double factor = A[row * m + col]; for(int k = 0; k < m; k++) A[row * m + k] -= factor * A[col * m + k]; b[row] -= factor * b[col]; } } for(int i = 0; i < m; i++) x[i] = b[i]; return true; }
Строка с ведущим элементом нормируется так, чтобы ведущий элемент стал равен ровно 1, затем эта строка, умноженная на соответствующий коэффициент, вычитается из каждой другой строки, чтобы обнулить все остальные элементы этого столбца. После обработки всех столбцов таким образом вектор b уже содержит решение и копируется в x.
3. Вывод коэффициентов каузального фильтра:
//+-------------------------------------------------------------------+ //| Solves the least-squares polynomial fit to derive this window's | //| Savitzky-Golay coefficients, evaluated at the most recent point | //| only (index 0 = "now"), since no future data is available in | //| live trading. This is the "causal" adaptation of the classic, | //| textbook Savitzky-Golay filter, which normally uses a centered, | //| symmetric window that includes future points. | //+-------------------------------------------------------------------+ bool ComputeCausalCoefficients(int windowSize, int polyOrder, double &coefs[]) { int n = windowSize; int m = polyOrder + 1; //--- Build the Vandermonde design matrix: each row is [1, x, x^2, ...] //--- for a time index x, where x = 0 is the most recent bar and //--- x = -(n-1) is the oldest bar in the window double A[]; if(ArrayResize(A, n * m) < 0) { Print("ComputeCausalCoefficients: ArrayResize(A) failed, error code: ", GetLastError()); return false; } for(int row = 0; row < n; row++) { double x = -(n - 1) + row; double power = 1.0; for(int col = 0; col < m; col++) { A[row * m + col] = power; power *= x; } }
Сигнатура функции изменилась с void на bool. Этот блок формирует матрицу плана Вандермонда, описанную в Идее 2: каждая строка содержит временной индекс одного бара, возведенный в последовательно возрастающие степени; сами индексы меняются от -(n-1) для самого старого бара до 0 для самого нового. Возвращаемое значение ArrayResize() проверяется напрямую: при сбое функция немедленно возвращает false, тогда как раньше она устанавливала внутренний флаг и продолжала выполнять остальные проверки с учетом этого флага.
//--- Normal equations: (A^T * A) * w = A^T * e0, where e0 selects //--- "evaluate the fitted polynomial at x = 0" — this reduces to solving //--- AtA * w = c, where c = [1, 0, 0, ...] since 0^0=1 and 0^k=0 for k>0 double AtA[]; if(ArrayResize(AtA, m * m) < 0) { Print("ComputeCausalCoefficients: ArrayResize(AtA) failed, error code: ", GetLastError()); return false; } for(int i = 0; i < m; i++) for(int j = 0; j < m; j++) { double sum = 0.0; for(int row = 0; row < n; row++) sum += A[row * m + i] * A[row * m + j]; AtA[i * m + j] = sum; }
Вместо непосредственного обращения матрицы A здесь формируется матрица нормальных уравнений AᵀA — это стандартный подход метода наименьших квадратов, который при фиксированном небольшом размере окна дает систему меньшего размера, более удобную для решения. В общем случае этот метод не обеспечивает большей численной устойчивости, чем прямое решение исходной системы: формирование AᵀA фактически возводит число обусловленности матрицы в квадрат, что ухудшает, а не улучшает обусловленность. Этот метод используется здесь потому, что при выбранных размерах окон и степенях полиномов получаемая система на практике остается достаточно хорошо обусловленной, а не потому, что нормальные уравнения сами по себе более устойчивы. При сбое ArrayResize() в этом месте функция теперь также сразу возвращает false: перед этой проверкой больше не нужно писать if(!allocationFailed &&...), поскольку при реальном сбое в предыдущем блоке функция уже завершилась бы и выполнение не дошло бы до этого места.
//--- c = [1, 0, 0, ...] encodes "evaluate the fitted polynomial at //--- x = 0" — only the constant term survives at that point double c[]; if(ArrayResize(c, m) < 0) { Print("ComputeCausalCoefficients: ArrayResize(c) failed, error code: ", GetLastError()); return false; } if(!ArrayInitialize(c, 0.0)) { Print("ComputeCausalCoefficients: ArrayInitialize(c) failed, error code: ", GetLastError()); return false; } c[0] = 1.0; double w[]; if(!SolveLinearSystem(AtA, c, m, w)) { Print("ComputeCausalCoefficients: Savitzky-Golay coefficient solve failed for window=", n); return false; }
Вектор c = [1, 0, 0,...] задает операцию "вычислить значение аппроксимирующего полинома при x = 0". Решение системы AᵀA·w = c дает коэффициенты, позволяющие выделить значение на самом новом баре. При отрицательном результате любой проверки в этом блоке (двух проверок вызовов ArrayResize / ArrayInitialize и проверки вызова SolveLinearSystem()) функция теперь немедленно возвращает false, а не устанавливает общий флаг allocationFailed, который использовался в старой версии.
//--- Finally, project the m-length polynomial-space solution back onto //--- the n raw data points: coefs[row] = A[row] dot w if(ArrayResize(coefs, n) < 0) { Print("ComputeCausalCoefficients: final ArrayResize(coefs) failed, error code: ", GetLastError()); return false; } for(int row = 0; row < n; row++) { double sum = 0.0; for(int col = 0; col < m; col++) sum += A[row * m + col] * w[col]; coefs[row] = sum; } return true; }
Здесь решение w из пространства полиномов проецируется обратно на фактические бары окна, в результате чего получаются окончательные веса для каждого бара. Теперь функция заканчивается оператором return true; — это явный и однозначный сигнал вызывающему коду о том, что coefs действительно содержит корректный результат. В этой функции больше нет ветви с резервным переходом к вычислению среднего: любой путь выполнения возвращает либо false при реальном сбое, либо true при успешном завершении.
4. Инициализация:
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- SetIndexBuffer() returns false if the binding fails — checked //--- here because if either buffer failed to bind, the indicator would //--- otherwise appear to load successfully while never actually //--- drawing anything, with no clear indication of why if(!SetIndexBuffer(0, BufFast, INDICATOR_DATA) || !SetIndexBuffer(1, BufSlow, INDICATOR_DATA)) { Print("OnInit: SetIndexBuffer failed, error code: ", GetLastError()); return INIT_FAILED; } PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE); IndicatorSetString(INDICATOR_SHORTNAME, "SG-Filter(" + IntegerToString(InpFastWindow) + "," + IntegerToString(InpSlowWindow) + ")");
Каждый буфер регистрируется в терминале и привязывается к соответствующей линии. SetIndexBuffer() возвращает false при сбое привязки, и здесь это явно проверяется. Без такой проверки при неудачной привязке индикатор внешне загружался бы нормально, но ничего не рисовал бы и не выдавал сообщения об ошибке, объясняющего причину. Установка PLOT_EMPTY_VALUE в EMPTY_VALUE гарантирует, что незаполненные точки буфера (например, на участке периода прогрева до появления первого корректного значения) будут пропущены при отрисовке, а не показаны как нулевые значения.
if(InpFastWindow < 3 || InpSlowWindow <= InpFastWindow) { Print("InpSlowWindow must be greater than InpFastWindow, and both at least 3."); return INIT_PARAMETERS_INCORRECT; } if(InpPolyOrder < 1 || InpPolyOrder >= InpFastWindow) { Print("InpPolyOrder must be at least 1 and less than InpFastWindow."); return INIT_PARAMETERS_INCORRECT; }
Эти две проверки отбраковывают конфигурации, которые либо не имеют смысла, либо являются математически некорректными. Лучше выявить эту проблему при инициализации и вывести понятное сообщение, чем позже столкнуться с непонятным сбоем во время выполнения.
//--- Precompute both filters' coefficients once — since they depend //--- only on window length and polynomial order, not on price data. //--- The return value is checked here rather than inside the function //--- itself, so the indicator can genuinely fail to initialize with a //--- clear error if the coefficients cannot be computed, rather than //--- silently substituting a lower-quality fallback the user is never //--- told about. if(!ComputeCausalCoefficients(InpFastWindow, InpPolyOrder, FastCoefs)) { Print("OnInit: failed to compute fast filter coefficients."); return INIT_FAILED; } if(!ComputeCausalCoefficients(InpSlowWindow, InpPolyOrder, SlowCoefs)) { Print("OnInit: failed to compute slow filter coefficients."); return INIT_FAILED; } return INIT_SUCCEEDED; }
Оба набора коэффициентов по-прежнему вычисляются здесь ровно один раз, а не внутри функции OnCalculate(), поскольку ни один из них не зависит от цены. Новое здесь то, что возвращаемое значение каждого вызова теперь проверяется напрямую: если хотя бы один из них действительно завершается с ошибкой, OnInit() сразу прерывает инициализацию индикатора и выводит понятное сообщение через Print(). В прежней реализации сбой молча игнорировался, а индикатор продолжал работать с менее качественной заменой, о которой пользователю не сообщалось.
5. Основной цикл вычислений:
//+------------------------------------------------------------------+ //| Custom indicator iteration function | //+------------------------------------------------------------------+ 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[]) { int warmupBars = InpSlowWindow + 1; if(rates_total < warmupBars + 2) return 0; ArraySetAsSeries(close, true); ArraySetAsSeries(BufFast, true); ArraySetAsSeries(BufSlow, true);
Медленное окно всегда длиннее быстрого, поэтому именно оно определяет, какой объем исторических данных необходим для вычисления первого значения. Для массива цен и обоих буферов явно задана индексация как в таймсерии, поэтому во всей функции индекс 0 неизменно указывает на самый новый бар.
//--- Determine the starting point for the calculation int start = rates_total - prev_calculated; //--- Perform a full initialization on the first calculation. //--- ArrayInitialize() returns false if it fails — checked here since a //--- silent failure would leave old, stale buffer values in place //--- rather than the clean EMPTY_VALUE state this reset is meant to produce if(prev_calculated <= 1) { if(!ArrayInitialize(BufFast, EMPTY_VALUE) || !ArrayInitialize(BufSlow, EMPTY_VALUE)) { Print("OnCalculate: ArrayInitialize failed, error code: ", GetLastError()); return 0; } start = rates_total - warmupBars - 1; } else { //--- Recalculate the current and most recently closed bar on live ticks if(start < 1) start = 1; }
При первом же вычислении оба буфера сбрасываются, и обрабатывается вся доступная история. В случае сбоя ArrayInitialize() возвращает false, и это явно проверяется: незамеченный сбой оставил бы в буферах устаревшие значения вместо пустого состояния, которое должен обеспечить сброс. При каждом последующем вызове повторно обрабатываются лишь те немногие бары, которые затронуты изменениями с момента предыдущего вызова.
for(int i = start; i >= 0; i--) { //--- Skip bars too close to the end of history for a full warm-up window if(i > rates_total - warmupBars - 1) continue; //--- Coefficient[0] pairs with the OLDEST bar in the window, //--- coefficient[last] with the CURRENT bar — matching how the //--- coefficients were derived in ComputeCausalCoefficients() double fastValue = 0.0; for(int j = 0; j < InpFastWindow; j++) fastValue += FastCoefs[InpFastWindow - 1 - j] * close[i + j]; BufFast[i] = fastValue; double slowValue = 0.0; for(int j = 0; j < InpSlowWindow; j++) slowValue += SlowCoefs[InpSlowWindow - 1 - j] * close[i + j]; BufSlow[i] = slowValue; } return rates_total; }
Поскольку для close[] используется индексация как в таймсерии, с ростом j выражение close[i+j] обращается ко все более ранним барам; индекс коэффициента InpFastWindow - 1 - j сопоставляет самый новый бар с коэффициентом, вычисленным для нулевой позиции, а самый старый — с коэффициентом для дальнего конца окна, в соответствии с тем, как были выведены коэффициенты.

Индикатор Савицкого — Голея на графике
Советник: подробный разбор всего кода
1. Входные параметры и глобальное состояние:
input double InpLotSize = 0.10; // Trade Volume input int InpConfirmBars = 5; // Bars a Crossover Must Hold Before Trading input int InpFastWindow = 50; // Fast Window Length (must match indicator's setting) input int InpSlowWindow = 100; // Slow Window Length (must match indicator's setting) input int InpPolyOrder = 2; // Polynomial Order (must match indicator's setting; keep at 2) input int InpMagicNumber = 20260002; // Magic Number
InpFastWindow, InpSlowWindow и InpPolyOrder в точности соответствуют входным параметрам индикатора, и их значения необходимо согласовывать вручную: советник не может считывать настройки экземпляра индикатора, установленного на графике, поскольку это два отдельных, независимых набора входных параметров, значения которых совпадают лишь благодаря настройкам пользователя. InpConfirmBars — это механизм обеспечения стабильности из Идеи 3. InpMagicNumber помечает магическим номером каждую позицию, открываемую этим советником; это важно, если на одном счете могут работать несколько советников или совершаться сделки вручную.
Стоит явно отметить один компромисс: InpConfirmBars = 5 добавляет задержку в пять закрытых баров, прежде чем советник отреагирует на пересечение. На часовом графике это пять часов; на дневном графике — пять торговых дней. Фильтр уменьшает запаздывание сглаживания, обусловленное окном, но требование подтверждения добавляет к нему собственную задержку. Будет ли суммарная задержка всей системы действительно меньше, чем при обычном пересечении скользящих средних с теми же длинами окон, зависит от таймфрейма и настроек; это следует проверять напрямую, а не предполагать, исходя лишь из свойств фильтра.
//--- Indicator handle. Fast/slow/poly are explicitly passed in here //--- rather than left to the indicator's own default inputs — this way //--- the EA's behaviour is fully defined by ITS OWN settings, and never //--- silently changes just because someone edits the indicator's //--- defaults on a chart elsewhere. int handleSG; //--- Tracks how many consecutive bars the fast/slow relationship has //--- held in its current state, and what that state currently is — this //--- is what implements the noise-filtering "stability confirmation" //--- discussed for this filter: a single noisy crossover is deliberately //--- ignored until it has genuinely persisted. string currentRelation = ""; int relationRunLength = 0; string lastConfirmedRelation = "";
handleSG — это дескриптор индикатора, который получают один раз в OnInit() и используют все время, пока советник прикреплен к графику. Это не копия данных индикатора: по дескриптору советник на каждом новом баре запрашивает актуальные данные через CopyBuffer(). Вместе эти три переменные обеспечивают отслеживание длины серии, на котором основан механизм обеспечения стабильности. Их состояние должно сохраняться между вызовами OnTick(), поэтому они объявлены глобальными, а не локальными переменными внутри функции.
2. Инициализация и очистка:
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- InpLotSize must be strictly positive if(InpLotSize <= 0.0) { Print("OnInit: InpLotSize must be greater than 0."); return INIT_PARAMETERS_INCORRECT; } if(InpConfirmBars < 1) { Print("OnInit: InpConfirmBars must be at least 1."); return INIT_PARAMETERS_INCORRECT; } if(InpSlowWindow <= InpFastWindow) { Print("OnInit: InpSlowWindow must be greater than InpFastWindow."); return INIT_PARAMETERS_INCORRECT; } if(InpPolyOrder < 1 || InpPolyOrder >= InpFastWindow) { Print("OnInit: InpPolyOrder must be at least 1 and less than InpFastWindow."); return INIT_PARAMETERS_INCORRECT; } //--- Validate InpLotSize against the symbol's actual volume constraints //--- SymbolInfoDouble() returns 0.0 on failure, which is checked before use double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN); double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX); double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP); if(minLot <= 0.0 || maxLot <= 0.0 || lotStep <= 0.0) { Print("OnInit: Failed to retrieve symbol volume constraints, error ", GetLastError()); return INIT_FAILED; } if(InpLotSize < minLot || InpLotSize > maxLot) { Print("OnInit: InpLotSize ", InpLotSize, " is outside the symbol's allowed range [", minLot, ", ", maxLot, "]."); return INIT_PARAMETERS_INCORRECT; } //--- Create the indicator handle — parameter order must match the //--- indicator's own input declaration exactly handleSG = iCustom(_Symbol, _Period, "The Causal Savitzky-Golay Trend Filter Indicator", InpFastWindow, InpSlowWindow, InpPolyOrder); if(handleSG == INVALID_HANDLE) { Print("OnInit: Failed to load the Savitzky-Golay Trend Filter indicator, error ", GetLastError()); return INIT_FAILED; } return INIT_SUCCEEDED; }
Это единственное место, где советник обращается к индикатору: он загружает его по имени через iCustom(), явно передавая собственные значения длины быстрого окна, длины медленного окна и степени полинома вместо значений по умолчанию.
Эти проверки дублируют проверки, выполняемые внутри самого индикатора, но их стоит независимо выполнять и на стороне советника, а не считать, что проверок индикатора достаточно для защиты от ошибок. Поскольку советник передает в iCustom() собственные копии этих значений, допущенная только на стороне советника ошибка (например, длина медленного окна меньше длины быстрого) иначе проявилась бы лишь позже в виде странного, труднообъяснимого торгового поведения, а не понятного сообщения об ошибке сразу при подключении советника.
//+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- IndicatorRelease() returns false if it fails — checked and logged //--- here purely for completeness; a failure at this specific point is //--- not something the EA can meaningfully recover from since it's //--- already shutting down, but silently ignoring it would still be //--- teaching the wrong habit if(handleSG != INVALID_HANDLE) { if(!IndicatorRelease(handleSG)) Print("OnDeinit: IndicatorRelease failed, error code: ", GetLastError()); } }
Освобождение дескриптора индикатора при деинициализации позволяет терминалу корректно освободить этот ресурс. Функция IndicatorRelease() возвращает false при сбое; здесь результат проверяется, а сбой записывается в журнал главным образом для полноты изложения, поскольку при завершении работы советник уже не может предпринять действенных мер для устранения такого сбоя. Однако игнорировать возвращаемое значение без какой-либо проверки означало бы подавать в учебной статье пример неправильной практики.
3. Вспомогательные функции управления позициями:
//+------------------------------------------------------------------+ //| Checks whether a position with our magic number is already open | //+------------------------------------------------------------------+ bool HasOpenPosition() { for(int i = PositionsTotal() - 1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); if(ticket == 0) continue; if(PositionGetString(POSITION_SYMBOL) == _Symbol && (long)PositionGetInteger(POSITION_MAGIC) == InpMagicNumber) return true; } return false; }
Эта функция просматривает все открытые позиции на счете и возвращает true, только если найдена позиция, соответствующая и данному торговому инструменту, и магическому номеру этого советника. При сравнении магических номеров к значению, возвращаемому PositionGetInteger(), явно применяется приведение (long), поскольку эта функция всегда возвращает 64-битное целое число. Именно проверка обоих условий, а не только торгового инструмента, позволяет этому советнику безопасно работать на счете, где по тому же торговому инструменту может работать другой советник или быть открыта позиция вручную: при этом ни одна из систем не примет чужую позицию за свою.
//+------------------------------------------------------------------+ //| Returns true when this EA holds a position of the given type | //| Used to verify direction before deciding to reverse or skip | //+------------------------------------------------------------------+ bool HasPositionOfType(ENUM_POSITION_TYPE posType) { for(int i = PositionsTotal() - 1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); if(ticket == 0) continue; if(PositionGetString(POSITION_SYMBOL) == _Symbol && (long)PositionGetInteger(POSITION_MAGIC) == InpMagicNumber && (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == posType) return true; } return false; }
Функция HasPositionOfType() дополняет ту же проверку торгового инструмента и магического номера третьим условием: она также проверяет, что тип открытой позиции совпадает с переданным в качестве аргумента — покупка или продажа. Приведение результата PositionGetInteger(POSITION_TYPE) к типу (ENUM_POSITION_TYPE) делает сравнение типов явным. Эта функция используется в тех случаях, когда советник должен убедиться не только в том, что позиция открыта, но и в том, что она открыта в определенном направлении.
//+------------------------------------------------------------------+ //| Closes any open position belonging to this EA on this symbol | //| Returns true only if every close was accepted by the server | //+------------------------------------------------------------------+ bool CloseOpenPosition() { bool allClosed = true; for(int i = PositionsTotal() - 1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); if(ticket == 0) continue; if(PositionGetString(POSITION_SYMBOL) != _Symbol || (long)PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue; MqlTradeRequest request = {}; MqlTradeResult result = {}; long posType = PositionGetInteger(POSITION_TYPE); double volume = PositionGetDouble(POSITION_VOLUME); //--- SymbolInfoDouble() returns 0 on failure — an order must never be //--- sent with price = 0, so the result is checked before use double closePrice = (posType == POSITION_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK); if(closePrice <= 0.0) { Print("CloseOpenPosition: SymbolInfoDouble failed, error: ", GetLastError()); allClosed = false; continue; } request.action = TRADE_ACTION_DEAL; request.position = ticket; request.symbol = _Symbol; request.volume = volume; request.magic = InpMagicNumber; request.type = (posType == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY; request.price = closePrice; request.deviation = 10; if(!OrderSend(request, result)) { Print("CloseOpenPosition: OrderSend failed for ticket #", ticket, ", error: ", GetLastError()); allClosed = false; continue; } //--- OrderSend() returning true only means the request was accepted //--- locally — the trading server may still refuse execution; retcode //--- must be checked to confirm the position was actually closed if(result.retcode != TRADE_RETCODE_DONE) { Print("CloseOpenPosition: Server rejected close for ticket #", ticket, ", retcode: ", result.retcode); allClosed = false; } } return allClosed; }
Функция CloseOpenPosition() теперь возвращает значение типа bool, тогда как раньше она ничего не возвращала. Внутренний флаг allClosed изначально имеет значение true и устанавливается в false, если не удалось закрыть хотя бы одну позицию: SymbolInfoDouble() вернула 0, OrderSend() вернула false или код возврата сервера не равен TRADE_RETCODE_DONE. Эта последняя проверка важна, поскольку возвращение функцией OrderSend() значения true означает лишь то, что запрос был принят на локальном уровне; окончательное решение по-прежнему принимает торговый сервер. Функция возвращает значение false, если закрытие какой-либо позиции в цикле завершилось неудачей, что позволяет функции OnTick() в таком случае отказаться от открытия противоположной позиции.
//+------------------------------------------------------------------+ //| Opens a new market position in the given direction | //| Returns true only if the order was accepted by the trading server| //+------------------------------------------------------------------+ bool OpenPosition(ENUM_ORDER_TYPE orderType) { MqlTradeRequest request = {}; MqlTradeResult result = {}; //--- Same price-validity check as in CloseOpenPosition() double openPrice = (orderType == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID); if(openPrice <= 0.0) { Print("OpenPosition: SymbolInfoDouble failed, error: ", GetLastError()); return false; } request.action = TRADE_ACTION_DEAL; request.symbol = _Symbol; request.volume = InpLotSize; request.type = orderType; request.price = openPrice; request.deviation = 10; request.magic = InpMagicNumber; if(!OrderSend(request, result)) { Print("OpenPosition: OrderSend failed, error: ", GetLastError()); return false; } //--- Check the server's actual execution result — OrderSend() returning //--- true only means local acceptance, not confirmed server execution if(result.retcode != TRADE_RETCODE_DONE) { Print("OpenPosition: Server rejected order, retcode: ", result.retcode); return false; } return true; }
Функция OpenPosition() также возвращает значение типа bool. Функция возвращает значение false в трех случаях: SymbolInfoDouble() возвращает 0, OrderSend() возвращает false или код возврата сервера не равен TRADE_RETCODE_DONE. Функция возвращает true только после того, как сервер подтвердит исполнение ордера. Функция OnTick() использует это возвращаемое значение для принятия решения о необходимости обновления lastConfirmedRelation.
4. Обработчик тиков:
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { static datetime lastBarTime = 0; //--- iTime() returns 0 if it fails (for example, if history for this //--- symbol/timeframe isn't yet synchronized) — checked explicitly, //--- since a silent failure here could otherwise leave the EA //--- permanently unable to detect a new bar datetime currentBarTime = iTime(_Symbol, _Period, 0); if(currentBarTime == 0) { Print("OnTick: iTime failed, error code: ", GetLastError()); return; } if(currentBarTime == lastBarTime) return; lastBarTime = currentBarTime;Это проверка появления нового бара. Функция iTime() возвращает 0 в случае сбоя — например, если история данного торгового инструмента еще не полностью синхронизирована. Это значение проверяется явно, поскольку иначе незаметный сбой в этом месте мог бы навсегда лишить советник возможности обнаруживать новые бары. Функция OnTick() срабатывает при каждом обновлении цены, но этот советник оценивает сигналы один раз за каждый бар.
//--- Read the most recently CLOSED bar's fast/slow values (index 1, //--- not 0 — bar 0 is still forming and its value may still change) double fastBuffer[], slowBuffer[]; if(CopyBuffer(handleSG, 0, 1, 1, fastBuffer) <= 0) return; if(CopyBuffer(handleSG, 1, 1, 1, slowBuffer) <= 0) return; //--- Guard against EMPTY_VALUE: the indicator may not yet have enough //--- history to produce a valid output for this bar — using an //--- EMPTY_VALUE in a comparison would silently bias every decision if(fastBuffer[0] == EMPTY_VALUE || slowBuffer[0] == EMPTY_VALUE) return; //--- Exact equality is treated as neutral — no directional assignment string newRelation; if(fastBuffer[0] > slowBuffer[0]) newRelation = "above"; else if(fastBuffer[0] < slowBuffer[0]) newRelation = "below"; else return; // Exact equality — neutral; skip this bar entirely
Функция CopyBuffer() считывает данные непосредственно из выходного буфера индикатора по индексу 1, который соответствует последнему закрытому бару. В этом файле вообще не выполняются вычисления для фильтра Савицкого — Голея. Это единственное место, где в советник поступает информация, полученная на основе цен.
//--- This is the noise-filtering safeguard discussed for this filter: //--- track how long the current above/below relationship has held, and //--- only treat it as a genuine, tradeable signal once it has persisted //--- for InpConfirmBars consecutive closed bars — a single noisy bar //--- flipping the relationship for just one bar is deliberately ignored. if(newRelation == currentRelation) relationRunLength++; else { currentRelation = newRelation; relationRunLength = 1; }
Это счетчик длины серии, лежащий в основе механизма обеспечения стабильности. Пока соотношение остается неизменным, счетчик увеличивается; как только оно меняется на противоположное, счетчик сбрасывается до 1. Конкретный пример: если параметр InpConfirmBars равен 5, а быстрая линия поднимается выше медленной и остается там всего 3 бара, после чего снова опускается ниже, значение relationRunLength так и не достигает 5 и сделка не совершается. Счетчик просто начинает отсчет заново с 1, отслеживая новое состояние "ниже". Именно этот механизм отфильтровывает единичное шумовое пересечение, описанное в Идее 3, без какой-либо отдельной логики обнаружения шума.
if(relationRunLength == InpConfirmBars && currentRelation != lastConfirmedRelation) { bool tradeExecuted = false; //--- No existing position: open directly in the confirmed direction if(!HasOpenPosition()) { if(currentRelation == "above") tradeExecuted = OpenPosition(ORDER_TYPE_BUY); else tradeExecuted = OpenPosition(ORDER_TYPE_SELL); } else { //--- Existing position: close first, then open in the new direction, //--- but only if the close was confirmed by the server bool closed = CloseOpenPosition(); if(closed) { if(currentRelation == "above") tradeExecuted = OpenPosition(ORDER_TYPE_BUY); else tradeExecuted = OpenPosition(ORDER_TYPE_SELL); } else Print("OnTick: Close failed — opposite open skipped to avoid double exposure."); } //--- Update the confirmed state ONLY after a successful trade if(tradeExecuted) lastConfirmedRelation = currentRelation; } }
Советник действует по сигналу только тогда, когда счетчик длины серии достигает ровно InpConfirmBars и выполняется условие currentRelation!= lastConfirmedRelation. Это предотвращает повторное срабатывание в состоянии, по которому уже была совершена сделка. Когда это условие выполняется, советник сначала проверяет, открыта ли уже позиция. Если открытой позиции нет, советник сразу открывает позицию в подтвержденном направлении. Если позиция уже открыта, советник сначала вызывает CloseOpenPosition() и открывает позицию в новом направлении только после подтверждения закрытия сервером. Если закрытие не удалось, открытие противоположной позиции пропускается и выводится предупреждение, что позволяет избежать непреднамеренного удвоения рыночной экспозиции.
Флаг tradeExecuted типа bool показывает, был ли ордер фактически принят сервером. Переменной lastConfirmedRelation присваивается значение currentRelation только в том случае, если tradeExecuted имеет значение true. Если сервер отклоняет ордер, сигнал остается необработанным, и советник повторит попытку на следующем баре, если условия по-прежнему выполняются. После совершения сделки по первому подтвержденному сигналу советник удерживает позицию в этом направлении до появления противоположного подтвержденного сигнала. До появления первого подтвержденного сигнала советник остается вне рынка. Он также может оказаться вне рынка, если торговый запрос завершится неудачей и повторная попытка не будет предпринята.
Примечания по проверке
Перед тестированием на исторических данных индикатор был добавлен на графики нескольких торговых инструментов с разными таймфреймами, чтобы убедиться, что его показания соответствуют описанному в Идее 1 и Идее 2. Перерисовки уже закрытых баров не наблюдалось: подтвержденное значение, считываемое по индексу 1, после закрытия соответствующего бара больше не меняется. Именно это значение советник использует для торговли. Отображение на графике — отдельный случай: значение по индексу 0 пересчитывается на каждом тике на основе цены закрытия текущего, еще формирующегося бара. Поэтому крайняя правая точка линии на графике может смещаться до закрытия этого бара. Это ожидаемое поведение, а не перерисовка истории, однако текущий конец линии индикатора и подтвержденное значение, используемое советником для торговли, — не одно и то же. Описанное в Идее 1 уменьшенное запаздывание также было визуально подтверждено сравнением со стандартной скользящей средней с той же длиной окна, прежде чем приступить к полноценному тестированию на исторических данных.
Результаты тестирования на исторических данных
Советник был протестирован на четырех торговых инструментах с различными характеристиками волатильности и трендовой динамики: XAU/USD (золото), EUR/USD, USD/JPY и AUD/USD. Все четыре теста были проведены с настройками, указанными ранее в этой статье: быстрое окно — 50, медленное окно — 100, степень полинома — 2, число баров подтверждения — 5. Тестирование выполнялось в тестере стратегий MetaTrader 5 на реальных исторических ценовых данных.
Результаты по разным торговым инструментам оказались неоднозначными и приведены здесь в точности в том виде, в каком их выдал тестер, без исключения каких-либо результатов. Это сделано намеренно: фильтр, предназначенный для выявления трендов, закономерно показывает разные результаты в зависимости от того, насколько выраженным и устойчивым было направленное движение по конкретному торговому инструменту за выбранный период. Публикация только успешных результатов тестирования исказила бы эту картину.
XAUUSD:
Торговля золотом принесла чистую прибыль в размере 4 147,67 доллара при начальном депозите в 5 000 долларов — существенный прирост, однако максимальная просадка составила 70,15%, а прибыльность (Profit Factor) — всего 1,08. Это означает, что, несмотря на высокий итоговый результат, валовая прибыль лишь ненамного превысила абсолютную величину валового убытка. Это сочетание показателей заслуживает внимательного рассмотрения: кривая средств показывает, что в феврале средства счета сократились более чем наполовину, прежде чем восстановиться. Таким образом, итоговый прирост действительно был получен, но путь к нему сопровождался сильными колебаниями.

Рисунок 1. XAU/USD — Кривая средств

Рисунок 2. XAU/USD — Отчет о тестировании на исторических данных
EURUSD:
За период тестирования торговля парой EUR/USD принесла убыток: чистый убыток составил 963,92 доллара, прибыльность — 0,87, а коэффициент Шарпа был отрицательным и составил −2,08. Кривая средств достигает пика в конце февраля, после чего довольно равномерно снижается на протяжении всей оставшейся части тестирования. По этому торговому инструменту было совершено больше всего сделок из четырех протестированных (1 411 сделок); итогом стал однозначный убыток, представленный здесь без корректировок.

Рисунок 3. EUR/USD — Кривая средств

Рисунок 4. EUR/USD — Отчет о тестировании на исторических данных
USDJPY:
Пара USD/JPY показала лучший результат из четырех: чистая прибыль составила 1 011,34 доллара, прибыльность — 1,38, а коэффициент Шарпа — 1,94. Результат с учетом риска оказался заметно лучше, чем по любому другому протестированному торговому инструменту. Кроме того, по этой паре было совершено меньше всего сделок среди четырех протестированных инструментов (275), что позволяет предположить, что за период тестирования фильтр выявил по ней меньше сигналов, но более высокого качества.

Рисунок 5. USD/JPY — Кривая средств

Рисунок 6. USD/JPY — Отчет о тестировании на исторических данных
AUDUSD:
Пара AUD/USD также принесла убыток: чистый убыток составил 781,86 доллара, прибыльность — 0,86, а коэффициент Шарпа — −1,73. Кривая средств демонстрирует более резкие колебания, чем у EUR/USD: в середине года наблюдался кратковременный рост, который в итоге сменился снижением, продолжавшимся до конца тестирования.

Рисунок 7. AUD/USD — Кривая средств

Рисунок 8. AUD/USD — Отчет о тестировании на исторических данных
О чем говорит такой разброс результатов: два из четырех торговых инструментов оказались прибыльными (золото и USD/JPY), а два — убыточными (EUR/USD и AUD/USD). Из двух прибыльных торговых инструментов только USD/JPY показал приемлемые показатели с учетом риска; максимальная просадка по золоту в 70,15% при прибыльности всего 1,08 означает, что этот результат не следует считать хорошим с учетом риска: чистая прибыль действительно была получена, но она сопровождалась уровнем риска, который едва ли оправдан при прибыльности, столь близкой к 1.
Результаты представлены такими, какими они были получены, в том числе по убыточным валютным парам. Фильтр полезен только для тех торговых инструментов и периодов, где наблюдается устойчивое направленное движение, которое можно отличить от шума. Если большую часть тестируемого периода движение торгового инструмента было шумным и не имело четкого направления, ни один метод следования за трендом, включая этот, не даст хороших результатов; это ограничение обусловлено рыночными условиями по данному инструменту в тот период, а не особенностями только этого фильтра. Прежде чем делать выводы о каком-либо конкретном рынке, читателям рекомендуется провести тестирование на выбранных ими торговых инструментах и периодах.
Ограничения
Для получения корректных значений индикатору требуется немного больше баров, чем указано в параметре InpSlowWindow. Это является следствием структуры цикла вычислений.
Коэффициенты многочлена вычисляются с помощью метода нормальных уравнений. Этот метод надежен при длинах окна и степени полинома, использованных в статье, однако одновременное увеличение обоих параметров может привести к численной неустойчивости. Значение по умолчанию InpPolyOrder = 2 следует сохранить, если нет особых причин для его увеличения.
Советник не использует стоп-лосс и тейк-профит. Позиция удерживается до появления подтвержденного сигнала в противоположном направлении. Это позволяет сосредоточить пример на стратегии пересечения, но оставляет позиции под угрозой крупных убытков при длительном движении цены в неблагоприятном направлении. Перед использованием в реальной торговле рекомендуется предусмотреть меры контроля рисков.
Как показано в Идее 3, этот фильтр более чувствителен к отдельным скачкам цен, чем обычная скользящая средняя. Параметр InpConfirmBars уменьшает количество ложных сигналов, но не устраняет эту чувствительность полностью.
При тестировании на исторических данных использовались фиксированные размеры лота для четырех торговых инструментов с различными характеристиками волатильности. Протестированные параметры не подбирались вслепую и не проходили проверку на вневыборочных данных. Сравнение с обычной стратегией пересечения скользящих средних с теми же длинами окон не проводилось. Полученные результаты отражают поведение стратегии в условиях, в которых проводилось тестирование, и не должны рассматриваться как прогноз будущих результатов.
Плюсы и минусы
| Плюсы | Минусы |
|---|---|
| Меньшее запаздывание. Каузальный полиномиальный фильтр реагирует на изменения цен быстрее, чем скользящая средняя с той же длиной окна, как показано в Идеях 1 и 3. | Повышенная чувствительность к шуму. Платой за более быстрый отклик становится более сильная реакция на отдельные скачки цен. |
| Простая архитектура. Индикатор предоставляет две выходные линии, которые советник считывает через функцию iCustom() без повторного выполнения вычислений. | Зависимость от настроек окна. Результаты зависят от параметров InpFastWindow и InpSlowWindow. Для разных торговых инструментов и таймфреймов могут потребоваться разные настройки. |
| Подтверждение сигнала. Параметр InpConfirmBars помогает уменьшить количество ложных сигналов, вызванных временными колебаниями цены. | Отсутствует встроенная система управления рисками. Позиции остаются открытыми до тех пор, пока не подтвердится противоположный сигнал, что может привести к значительным просадкам. |
| Многообещающие результаты на некоторых инструментах. Золото и пара USD/JPY показали хорошие результаты в ходе тестирования, причем коэффициент Шарпа для пары USD/JPY составил 1,94. | Неоднозначные результаты тестирования на исторических данных. За период тестирования пары EUR/USD и AUD/USD принесли убытки. Эта стратегия, по-видимому, лучше подходит для устойчивых трендов, чем для бокового движения рынка. |
Как пользоваться
- Скомпилируйте оба файла в MetaEditor — сначала индикатор, а затем советник, поскольку советник загружает индикатор по имени и не сможет инициализироваться, если не найдет его скомпилированную версию.
- Сначала добавьте на график только индикатор и после загрузки достаточного объема исторических данных убедитесь, что обе линии отображаются правильно (синяя — быстрая, оранжево-красная — медленная).
- Добавьте советник на график того же торгового инструмента с тем же таймфреймом. Задайте для InpFastWindow, InpSlowWindow и InpPolyOrder те же значения, что использует индикатор: это независимые входные параметры советника, и их значения не считываются автоматически из настроек индикатора на графике.
- Интерпретируйте эти две линии так же, как пересечение скользящих средних: положение быстрой линии выше медленной указывает на согласованное движение цены вверх, а ниже — вниз. Само по себе расстояние между ними не имеет того значения, которое оно может иметь у некоторых осцилляторов: этот инструмент показывает направление, а не величину движения.
- Прежде чем запускать советник на реальном или демо-счете, проведите тестирование на исторических данных для выбранного торгового инструмента и таймфрейма, руководствуясь рекомендациями из раздела "Ограничения" по выбору длины окна и настройке числа баров подтверждения.
Заключение
В этой статье была подробно рассмотрена конкретная, четко сформулированная проблема (запаздывание, присущее любой скользящей средней) и конкретное, проверенное решение: адаптация спектроскопической методики пятидесятилетней давности для каузальной работы, то есть с использованием только прошлых данных, что позволяет применять ее в реальной торговле. Математические соотношения были выведены и независимо проверены до реализации; возникающий при этом компромисс, связанный с чувствительностью к шуму, оценили количественно, а не проигнорировали. Механизм обеспечения стабильности в прилагаемом советнике был разработан специально для учета этого количественно оцененного компромисса, а не как универсальное дополнение.
Были представлены фактические результаты тестирования на исторических данных по четырем различным торговым инструментам в том виде, в каком они были получены, включая неблагоприятные: ведь если для метода сглаживания показывают только лучшие результаты, это не доказывает его работоспособность, а лишь свидетельствует о выборочной публикации результатов. Читателям рекомендуется протестировать этот метод на выбранных ими торговых инструментах, прежде чем делать выводы о его полезности для своей торговли.
Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/24393
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.