Discussão do artigo "Desenvolvendo um EA multimoeda (Parte 2): Transição para posições virtuais de estratégias de trading"
Ainda não terminei de lê-lo. As entradas são um bom exemplo.
1.
input string symbol_ = "EURGBP"; // Instrumento de negociação (símbolo) input ENUM_TIMEFRAMES timeframe_ = PERIOD_H1; // Período da programação input group "=== Parâmetros do sinal de abertura" input int signalPeriod_ = 13; // Número de velas para cálculo da média de volume input double signalDeviation_ = 0.3; // Desvio relativo da média para a abertura da primeira ordem input double signaAddlDeviation_ = 1.0; // Desvio relativo da média para a abertura da segunda ordem e das ordens subsequentes input group "=== Parâmetros de pedidos pendentes." input int openDistance_ = 0; // Distância do preço até a ordem pendente input double stopLevel_ = 10500; // Stop Loss (em pontos) input double takeLevel_ = 465; // Take Profit (em pips) input int ordersExpiration_ = 1000; // Tempo de expiração das ordens pendentes (em minutos) input group "=== Opções de gerenciamento de capital" input int maxCountOfOrders_ = 3; // Número máximo de ordens abertas simultaneamente
int OnInit() { expert = new CAdvisor(new CVolumeReceiver(magic_)); expert.Add(new CSimpleVolumesStrategy( symbol_, timeframe_, fixedLot_, signalPeriod_, signalDeviation_, signaAddlDeviation_, openDistance_, stopLevel_, takeLevel_, ordersExpiration_, maxCountOfOrders_) ); // Adicionar uma instância da estratégia return(INIT_SUCCEEDED); }
class CSimpleVolumesStrategy : public CStrategy { private: //--- Parâmetros do sinal de abertura int m_signalPeriod; // Número de velas para cálculo da média de volume double m_signalDeviation; // Desvio relativo da média para a abertura da primeira ordem double m_signaAddlDeviation; // Desvio relativo da média para a abertura da segunda ordem e das ordens subsequentes //--- Parâmetros de ordens pendentes int m_openDistance; // Distância do preço até a ordem pendente double m_stopLevel; // Stop Loss (em pontos) double m_takeLevel; // Take Profit (em pips) int m_ordersExpiration; // Tempo de expiração das ordens pendentes (em minutos) //--- Parâmetros de gerenciamento de capital int m_maxCountOfOrders; // Número máximo de ordens abertas simultaneamente
4.
public: //--- Métodos públicos CSimpleVolumesStrategy( string p_symbol, ENUM_TIMEFRAMES p_timeframe, double p_fixedLot, int p_signalPeriod, double p_signalDeviation, double p_signaAddlDeviation, int p_openDistance, double p_stopLevel, double p_takeLevel, int p_ordersExpiration, int p_maxCountOfOrders );
5-6.
//+------------------------------------------------------------------+ //| Construtor| //+------------------------------------------------------------------+ CSimpleVolumesStrategy::CSimpleVolumesStrategy( string p_symbol, ENUM_TIMEFRAMES p_timeframe, double p_fixedLot, int p_signalPeriod, double p_signalDeviation, double p_signaAddlDeviation, int p_openDistance, double p_stopLevel, double p_takeLevel, int p_ordersExpiration, int p_maxCountOfOrders) : // Lista de inicialização CStrategy(p_symbol, p_timeframe, p_fixedLot), // Chamar o construtor da classe base m_signalPeriod(p_signalPeriod), m_signalDeviation(p_signalDeviation), m_signaAddlDeviation(p_signaAddlDeviation), m_openDistance(p_openDistance), m_stopLevel(p_stopLevel), m_takeLevel(p_takeLevel), m_ordersExpiration(p_ordersExpiration), m_maxCountOfOrders(p_maxCountOfOrders) { ArrayResize(m_orders, m_maxCountOfOrders); // Carregar o indicador para obter volumes de ticks iVolumesHandle = iVolumes(m_symbol, m_timeframe, VOLUME_TICK); // Defina o tamanho da matriz receptora de volumes de ticks e o endereçamento necessário ArrayResize(volumes, m_signalPeriod); ArraySetAsSeries(volumes, true); }
Cada parâmetro de entrada deve ser prescrito cinco ou seis vezes.
Leia o artigo. Graças ao autor, ele fez uma boa sondagem sobre as direções que podemos seguir.
Uma observação poderosa, após a qual não faz sentido criticar, mas devemos ir direto para a parte construtiva - sugerir.
O artigo discute o conceito de negociação virtual seguido pela sincronização unidirecional da negociação virtual com a negociação real. Como exemplo para o testador, ele serve. Mas apenas como um exemplo.
Na prática, esse portfólio TS é construído a partir do EX5 (gratuito para o testador) - executar, obter arquivos tst de execuções únicas, fazer uma execução única conjunta com quaisquer regras MM a partir deles.
Para o testador, você precisa de velocidade. Tente estimar o quanto a velocidade de otimização muda para a variante com e sem virtualização.
O conceito em si é bom para negociações reais. Mas, para o sincronizador, você terá que manter o histórico da negociação virtual. Há uma série de coisas. Uma maneira séria, para dizer o mínimo.
Arquitetonicamente, a virtualização seria separada do TS. Tenho apenas a fonte atual de virtualização de 350 Kb. E ela crescerá.
Abordar com cuidado a escolha da API de negociação para negociação virtual. Escolha entre as disponíveis. É lógico dar preferência à API, na qual é o mais fácil possível programar o TS. Eu realmente não entendo a prática comum de todas as plataformas de negociação de inventar sua própria bicicleta - API de negociação. Para dotá-la de entidades OOP "prontas para uso", etc. Nesse sentido, o MQ seguiu um bom caminho - todas as APIs sem OOP.
Antes de ler esses artigos, sempre dou uma olhada nos resultados dos testes. Pelo menos no testador. Quando vi 19% de lucro durante 5 anos, fiquei leve e feliz! Isso é muito mais do que o autor de 75 artigos sobre redes neurais! ))
Mas agora está claro como ganhar dinheiro garantido no Forex. Eu costumava pensar apenas em ensinar os otários sobre as ondas de Elliot, mas acontece que ainda há uma ótima maneira )).
Mas agora está claro como ganhar dinheiro garantido no Forex. Eu costumava pensar apenas em ensinar aos otários sobre as ondas de Elliot, mas acontece que ainda há uma ótima maneira )).
Não posso resistir a observar aqui que 19% dos lucros durante cinco anos no teste foram obtidos por um lote constante nas condições de rebaixamento inferior a US$ 1.000, ou seja, 1%. Se você se concentrar no drawdown máximo de até 10% e usar um lote variável, os resultados serão ainda mais interessantes.
//+------------------------------------------------------------------+ //|SimpleVolumesExpertSingle.mq5 //|Direitos autorais 2024, Yuriy Bykov | //| https://www.mql5.com/pt/users/antekov | //+------------------------------------------------------------------+ #property copyright "Copyright 2024, Yuriy Bykov" #property link "https://www.mql5.com/pt/articles/14107" #property description "A ordem pendente do Expert Advisor no momento em que o volume de ticks do candle excede o volume médio," #property description "na direção da vela atual". #property description "Se as ordens ainda não tiverem se transformado em posições, elas serão excluídas no momento da expiração." #property description "As posições abertas são fechadas apenas no SL ou TP." #include "Advisor.mqh" #include "SimpleVolumesStartegy.mqh"
Um erro de digitação.
Na prática, esse portfólio de TS é criado a partir do EX5 (gratuito no Market for the Tester) - execute, obtenha arquivos tst de passagens únicas e, a partir deles, faça uma única execução conjunta com quaisquer regras de MM.
Ainda não considerei essa opção, mas vou ter em mente que ela também é possível. Entretanto, se eu conseguir encontrar um bom conjunto de Expert Advisors prontos no mercado, como posso usá-los em conjunto? Basta executar todo o conjunto com os parâmetros MM selecionados?
Para o testador, você precisa de velocidade. Tente estimar o quanto a velocidade de otimização muda para a variante com e sem virtualização.
Vou tentar, mas parece que o ganho será perceptível quando o número de estratégias em execução simultânea for de dezenas ou centenas de instâncias.
Continuo querendo entrar em mais detalhes sobre o uso de sua biblioteca virtual para acelerar os testes, mas ainda não consegui fazer isso. O principal motivo é que estou acostumado com as funções de negociação do MT5, embora, quando tive que redesenhar meus Expert Advisors do MT4 para o MT5, tenha havido muitos inconvenientes relacionados a isso, e aprendi sobre o Virtual mais tarde.
Agora estou pensando em criar uma classe filha do CReceiver, que usará o ambiente Virtual.
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso
Novo artigo Desenvolvendo um EA multimoeda (Parte 2): Transição para posições virtuais de estratégias de trading foi publicado:
Vamos continuar a desenvolver o EA multimoeda com várias estratégias funcionando paralelamente. Tentaremos transferir todo o trabalho relacionado à abertura de posições a mercado do nível das estratégias para o nível do expert que gerencia as estratégias. As próprias estratégias irão negociar apenas virtualmente, sem abrir posições a mercado.
No artigo anterior, começamos a desenvolver o EA multimoeda, operando simultaneamente com diferentes estratégias de trading. Na primeira etapa, havia apenas duas estratégias diferentes. Elas representavam a implementação da mesma ideia de trading, operando no mesmo instrumento de trading (símbolo) e período de gráfico (timeframe). A única diferença entre elas eram os valores numéricos dos parâmetros.
Também determinamos o tamanho ideal das posições a serem abertas, com base no nível máximo desejado de rebaixamento (10% do depósito). Fizemos isso para cada estratégia separadamente. Quando combinamos as duas estratégias, para manter o nível de rebaixamento desejado, tivemos que reduzir o tamanho das posições abertas. Para duas estratégias, a redução foi pequena. Mas e se quisermos combinar dezenas ou centenas de estratégias? Pode acontecer que algumas estratégias precisem reduzir o tamanho das posições para um valor menor do que o mínimo permitido pelo corretor. Nesse caso, essas estratégias simplesmente não poderão participar do trading. Como fazer com que elas funcionem?
Para isso, vamos retirar das estratégias o direito de abrir posições e colocar ordens pendentes de forma independente. As estratégias devem negociar apenas virtualmente, ou seja, memorizar os níveis em que as posições de determinado tamanho devem ser abertas e, sob demanda, informar qual volume deve estar aberto no momento. Abriremos posições a mercado reais somente após consultar todas as estratégias e calcular o volume total necessário, levando em consideração a escala para manter o rebaixamento desejado.
No momento, estaremos interessados apenas em testar a viabilidade dessa abordagem, e não na eficiência de sua implementação. Portanto, neste artigo, tentaremos escrever uma implementação funcional dessa abordagem, que nos ajudará a construir uma mais elegante do ponto de vista arquitetônico no futuro. Isso nos ajudará não no sentido de melhorar a existente, mas de entender o que não devemos fazer e como podemos fazer de outra forma, de maneira melhor.
Autor: Yuriy Bykov