forked from antekov/Adwizard
//+------------------------------------------------------------------+
| |
//| SimpleVolumesStrategy.mqh |
| |
//| Copyright 2024, Yuriy Bykov |
| |
//| https://www.mql5.com/ru/users/antekov |
| |
//+------------------------------------------------------------------+
| |
#property copyright "Copyright 2024, Yuriy Bykov"
| |
#property link "https://www.mql5.com/ru/articles/16452"
| |
#property version "1.11"
| |
| |
#include "../Utils/NewBarEvent.mqh"
| |
#include "../Virtual/VirtualStrategy.mqh"
| |
| |
/** Описание стратегии
| |
| |
Входные параметры стратегии:
| |
- Символ
| |
- Период
| |
- Количество свечей для усреднения объемов (K)
| |
- Относительное отклонение от среднего для открытия первого ордера (D)
| |
- Относительное отклонение от среднего для открытия второго и последующих ордеров (D_add)
| |
- Расстояние от цены до отложенного ордера
| |
- Stop Loss (в пунктах)
| |
- Take Profit (в пунктах)
| |
- Время истечения отложенных ордеров (в минутах)
| |
- Максимальное количество одновременно отрытых ордеров (N_max)
| |
- Объем одного ордера
| |
| |
Находим количество открытых ордеров и позиций (N).
| |
Если оно меньше N_max, то:
| |
- вычисляем средний тиковый объём за последние K закрытых свечей, получаем величину V_avr.
| |
- Если выполнено условие V > V_avr * (1 + D + N * D_add), то:
| |
- определяем направление изменения цены на текущей свече: если цена увеличилась,
| |
то будем выставлять BUY, BUY_STOP или BUY_LIMIT, а иначе - SELL, SELL_STOP или SELL_LIMIT
| |
- выставляем рыночный или отложенный ордер исходя из заданного в параметрах расстояния
| |
(0 - рыночный, >0 - отложенный стоповый, <0 - отложенный лимитный),
| |
времени истечения и уровнями StopLoss и TakeProfit.
| |
*/
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| Торговая стратегия с использованием тиковых объемов |
| |
//+------------------------------------------------------------------+
| |
class CSimpleVolumesStrategy : public CVirtualStrategy {
| |
protected:
| |
string m_symbol; // Символ (торговый инструмент)
| |
ENUM_TIMEFRAMES m_timeframe; // Период графика (таймфрейм)
| |
| |
//--- Параметры сигнала к открытию
| |
int m_signalPeriod; // Количество свечей для усреднения объемов
| |
double m_signalDeviation; // Относ. откл. от среднего для открытия первого ордера
| |
double m_signaAddlDeviation; // Относ. откл. от среднего для открытия второго и последующих ордеров
| |
| |
//--- Параметры отложенных ордеров
| |
int m_openDistance; // Расстояние от цены до отлож. ордера
| |
double m_stopLevel; // Stop Loss (в пунктах)
| |
double m_takeLevel; // Take Profit (в пунктах)
| |
int m_ordersExpiration; // Время истечения отложенных ордеров (в минутах)
| |
| |
//--- Параметры управление капиталом
| |
int m_maxCountOfOrders; // Макс. количество одновременно отрытых ордеров
| |
| |
CSymbolInfo *m_symbolInfo; // Объект для получения информации о свойствах символа
| |
| |
int m_iVolumesHandle; // Хэндл индикатора тиковых объемов
| |
double m_volumes[]; // Массив-приемник значений индикатора (самих объемов)
| |
| |
//--- Методы
| |
int SignalForOpen(); // Сигнал для открытия отложенных ордеров
| |
void OpenBuyOrder(); // Открытие ордера BUY_STOP
| |
void OpenSellOrder(); // Открытие ордера SELL_STOP
| |
double ArrayAverage(
| |
const double &array[]); // Среднее значение массива чисел
| |
| |
public:
| |
//--- Публичные методы
| |
CSimpleVolumesStrategy(string p_params); // Конструктор
| |
| |
virtual string operator~() override; // Преобразование объекта в строку
| |
| |
virtual void Tick() override; // Обработчик события OnTick
| |
virtual void Save() override; // Сохранение состояния
| |
virtual bool Load() override; // Загрузка состояния
| |
| |
// Замена названий символов
| |
virtual bool SymbolsReplace(CHashMap<string, string> &p_symbolsMap);
| |
};
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| Конструктор |
| |
//+------------------------------------------------------------------+
| |
CSimpleVolumesStrategy::CSimpleVolumesStrategy(string p_params) {
| |
m_params = p_params;
| |
m_symbol = ReadString(p_params);
| |
m_timeframe = (ENUM_TIMEFRAMES) ReadLong(p_params);
| |
m_signalPeriod = (int) ReadLong(p_params);
| |
m_signalDeviation = ReadDouble(p_params);
| |
m_signaAddlDeviation = ReadDouble(p_params);
| |
m_openDistance = (int) ReadLong(p_params);
| |
m_stopLevel = ReadDouble(p_params);
| |
m_takeLevel = ReadDouble(p_params);
| |
m_ordersExpiration = (int) ReadLong(p_params);
| |
m_maxCountOfOrders = (int) ReadLong(p_params);
| |
| |
if(IsValid()) {
| |
CVirtualReceiver::Get(GetPointer(this), m_orders, m_maxCountOfOrders);
| |
| |
// Загружаем индикатор для получения тиковых объемов
| |
m_iVolumesHandle = iVolumes(m_symbol, m_timeframe, VOLUME_TICK);
| |
| |
// Если индикатор загружен успешно
| |
if(m_iVolumesHandle != INVALID_HANDLE) {
| |
| |
// Устанавливаем размер массива-приемника тиковых объемов и нужную адресацию
| |
ArrayResize(m_volumes, m_signalPeriod);
| |
ArraySetAsSeries(m_volumes, true);
| |
| |
// Регистрируем обработчик события нового бара на минимальном таймфрейме
| |
//IsNewBar(m_symbol, PERIOD_M1);
| |
| |
m_symbolInfo = CSymbolsMonitor::Instance()[m_symbol];
| |
} else {
| |
// Иначе устанавливаем ошибочное состояние объекта
| |
SetInvalid(__FUNCTION__, "Can't load iVolumes()");
| |
}
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Преобразование объекта в строку |
| |
//+------------------------------------------------------------------+
| |
string CSimpleVolumesStrategy::operator~() {
| |
return StringFormat("%s(%s)", typename(this), m_params);
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| "Tick" event handler function |
| |
//+------------------------------------------------------------------+
| |
void CSimpleVolumesStrategy::Tick() override {
| |
if(IsNewBar(m_symbol, PERIOD_M1)) {
| |
// Если их количество меньше допустимого
| |
if(m_ordersTotal < m_maxCountOfOrders) {
| |
// Получаем сигнал на открытие
| |
int signal = SignalForOpen();
| |
| |
if(signal == 1 /* || m_ordersTotal < 1 */) { // Если сигнал на покупку, то
| |
OpenBuyOrder(); // открываем ордер BUY_STOP
| |
} else if(signal == -1) { // Если сигнал на продажу, то
| |
OpenSellOrder(); // открываем ордер SELL_STOP
| |
}
| |
}
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Замена названий символов |
| |
//+------------------------------------------------------------------+
| |
bool CSimpleVolumesStrategy::SymbolsReplace(CHashMap<string, string> &p_symbolsMap) {
| |
// Если в словаре есть ключ, совпадающий с текущим символом
| |
if(p_symbolsMap.ContainsKey(m_symbol)) {
| |
string targetSymbol; // Целевой символ
| |
| |
// Если целевой символ для текущего успешно получен из словаря
| |
if(p_symbolsMap.TryGetValue(m_symbol, targetSymbol)) {
| |
// Обновляем текущий символ
| |
m_symbol = targetSymbol;
| |
}
| |
}
| |
| |
return true;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Сигнал для открытия отложенных ордеров |
| |
//+------------------------------------------------------------------+
| |
int CSimpleVolumesStrategy::SignalForOpen() {
| |
// По-умолчанию сигнала на открытие нет
| |
int signal = 0;
| |
| |
// Копируем значения объемов из индикаторного буфера в массив-приёмник
| |
int res = CopyBuffer(m_iVolumesHandle, 0, 0, m_signalPeriod, m_volumes);
| |
| |
// Если скопировалось нужное количество чисел
| |
if(res == m_signalPeriod) {
| |
// Вычисляем их среднее значение
| |
double avrVolume = ArrayAverage(m_volumes);
| |
| |
// Если текущий объем превысил заданный уровень, то
| |
if(m_volumes[0] > avrVolume * (1 + m_signalDeviation + m_ordersTotal * m_signaAddlDeviation)) {
| |
// если цена открытия свечи меньше текущей цены (закрытия), то
| |
if(iOpen(m_symbol, m_timeframe, 0) < iClose(m_symbol, m_timeframe, 0)) {
| |
signal = 1; // сигнал на покупку
| |
} else {
| |
signal = -1; // иначе - сигнал на продажу
| |
}
| |
}
| |
}
| |
| |
return signal;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Открытие ордера BUY |
| |
//+------------------------------------------------------------------+
| |
void CSimpleVolumesStrategy::OpenBuyOrder() {
| |
// Обновляем информацию о текущих ценах для символа
| |
//m_symbolInfo.Name(m_symbol);
| |
//m_symbolInfo.RefreshRates();
| |
| |
// Берем необходимую нам информацию о символе и ценах
| |
double point = m_symbolInfo.Point();
| |
int digits = m_symbolInfo.Digits();
| |
double bid = m_symbolInfo.Bid();
| |
double ask = m_symbolInfo.Ask();
| |
int spread = (int) ((ask - bid) / point); //m_symbolInfo.Spread();
| |
| |
// Сделаем, чтобы расстояние открытия было не меньше спреда
| |
int distance = MathMax(MathAbs(m_openDistance), spread) * (m_openDistance < 0 ? -1 : 1);
| |
| |
// Цена открытия
| |
double price = ask + distance * point;
| |
| |
// Уровни StopLoss и TakeProfit
| |
double sl = NormalizeDouble(price - m_stopLevel * point, digits);
| |
double tp = NormalizeDouble(price + (m_takeLevel + spread) * point, digits);
| |
| |
// Время истечения
| |
datetime expiration = TimeCurrent() + m_ordersExpiration * 60;
| |
| |
bool res = false;
| |
for(int i = 0; i < m_maxCountOfOrders; i++) { // Перебираем все виртуальные позиции
| |
if(!m_orders[i].IsOpen()) { // Если нашли не открытую, то открываем
| |
if(m_openDistance > 0) {
| |
// Устанавливаем отложенный ордер SELL STOP
| |
res = m_orders[i].Open(m_symbol, ORDER_TYPE_BUY_STOP, m_fixedLot,
| |
NormalizeDouble(price, digits),
| |
NormalizeDouble(sl, digits),
| |
NormalizeDouble(tp, digits),
| |
"", expiration);
| |
| |
} else if(m_openDistance < 0) {
| |
// Устанавливаем отложенный ордер SELL LIMIT
| |
res = m_orders[i].Open(m_symbol, ORDER_TYPE_BUY_LIMIT, m_fixedLot,
| |
NormalizeDouble(price, digits),
| |
NormalizeDouble(sl, digits),
| |
NormalizeDouble(tp, digits),
| |
"", expiration);
| |
| |
} else {
| |
// Открытие виртуальной позиции SELL
| |
res = m_orders[i].Open(m_symbol, ORDER_TYPE_BUY, m_fixedLot,
| |
0,
| |
NormalizeDouble(sl, digits),
| |
NormalizeDouble(tp, digits));
| |
| |
}
| |
break; // и выходим
| |
}
| |
}
| |
| |
if(!res) {
| |
PrintFormat(__FUNCTION__" | ERROR opening BUY virtual order", 0);
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Открытие ордера SELL |
| |
//+------------------------------------------------------------------+
| |
void CSimpleVolumesStrategy::OpenSellOrder() {
| |
// Обновляем информацию о текущих ценах для символа
| |
//m_symbolInfo.Name(m_symbol);
| |
//m_symbolInfo.RefreshRates();
| |
| |
// Берем необходимую нам информацию о символе и ценах
| |
double point = m_symbolInfo.Point();
| |
int digits = m_symbolInfo.Digits();
| |
double bid = m_symbolInfo.Bid();
| |
double ask = m_symbolInfo.Ask();
| |
int spread = (int) ((ask - bid) / point); //m_symbolInfo.Spread();
| |
| |
// Сделаем, чтобы расстояние открытия было не меньше спреда
| |
int distance = MathMax(MathAbs(m_openDistance), spread) * (m_openDistance < 0 ? -1 : 1);
| |
| |
// Цена открытия
| |
double price = bid - distance * point;
| |
| |
// Уровни StopLoss и TakeProfit
| |
double sl = NormalizeDouble(price + m_stopLevel * point, digits);
| |
double tp = NormalizeDouble(price - (m_takeLevel + spread) * point, digits);
| |
| |
// Время истечения
| |
datetime expiration = TimeCurrent() + m_ordersExpiration * 60;
| |
| |
bool res = false;
| |
for(int i = 0; i < m_maxCountOfOrders; i++) { // Перебираем все виртуальные позиции
| |
if(!m_orders[i].IsOpen()) { // Если нашли не открытую, то открываем
| |
if(m_openDistance > 0) {
| |
// Устанавливаем отложенный ордер SELL STOP
| |
res = m_orders[i].Open(m_symbol, ORDER_TYPE_SELL_STOP, m_fixedLot,
| |
NormalizeDouble(price, digits),
| |
NormalizeDouble(sl, digits),
| |
NormalizeDouble(tp, digits),
| |
"", expiration);
| |
| |
} else if(m_openDistance < 0) {
| |
// Устанавливаем отложенный ордер SELL LIMIT
| |
res = m_orders[i].Open(m_symbol, ORDER_TYPE_SELL_LIMIT, m_fixedLot,
| |
NormalizeDouble(price, digits),
| |
NormalizeDouble(sl, digits),
| |
NormalizeDouble(tp, digits),
| |
"", expiration);
| |
| |
} else {
| |
// Открытие виртуальной позиции SELL
| |
| |
res = m_orders[i].Open(m_symbol, ORDER_TYPE_SELL, m_fixedLot,
| |
0,
| |
NormalizeDouble(sl, digits),
| |
NormalizeDouble(tp, digits));
| |
}
| |
break; // и выходим
| |
}
| |
}
| |
| |
if(!res) {
| |
PrintFormat(__FUNCTION__" | ERROR opening SELL virtual order", 0);
| |
}
| |
}
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| Среднее значение массива чисел со второго элемента |
| |
//+------------------------------------------------------------------+
| |
double CSimpleVolumesStrategy::ArrayAverage(const double &array[]) {
| |
double s = 0;
| |
int total = ArraySize(array) - 1;
| |
for(int i = 1; i <= total; i++) {
| |
s += array[i];
| |
}
| |
| |
return s / MathMax(1, total);
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Сохранение состояния |
| |
//+------------------------------------------------------------------+
| |
void CSimpleVolumesStrategy::Save() {
| |
double avrVolume = ArrayAverage(m_volumes);
| |
| |
// Сформируем общую часть ключа с типом и хешем стратегии
| |
string key = "CSimpleVolumesStrategy[" + this.Hash() + "]";
| |
| |
// Сохраняем средний тиковый объём
| |
CStorage::Set(key + ".avrVolume", avrVolume);
| |
| |
// Сохраняем массив тиковых объёмов
| |
CStorage::Set(key + ".m_volumes", m_volumes);
| |
| |
// Вызываем метод базового класса (для сохранения виртуальных позиций)
| |
CVirtualStrategy::Save();
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Загрузка состояния |
| |
//+------------------------------------------------------------------+
| |
bool CSimpleVolumesStrategy::Load() {
| |
bool res = true;
| |
| |
double avrVolume = 0;
| |
| |
// Сформируем общую часть ключа с типом и хешем стратегии
| |
string key = "CSimpleVolumesStrategy[" + this.Hash() + "]";
| |
| |
// Загружаем массив тиковых объёмов
| |
res &= CStorage::Get(key + ".avrVolume", avrVolume);
| |
| |
// Загружаем массив тиковых объёмов
| |
res &= CStorage::Get(key + ".m_volumes", m_volumes);
| |
| |
// Вызываем метод базового класса (для загрузки виртуальных позиций)
| |
res &= CVirtualStrategy::Load();
| |
| |
return res;
| |
}
| |
//+------------------------------------------------------------------+
|