Eleve os seus sistemas de negociação lineares ao poder

26 março 2014, 13:47
Jordi Bassaganas
0
1 072

Introdução

O artigo de hoje mostra a programadores MQL5 intermediários como eles podem obter mais lucro de seus sistemas de negociação lineares (Fixed Lot) facilmente implementando a chamada técnica de exponenciação. O termo geral de exponenciação é usado aqui para se referir a esses modelos de gestão monetária que se adaptam ao tamanho ou ao número das posições colocadas no mercado de acordo com o risco que se tem. Isto é porque o crescimento de curva de capital resultante é, em seguida, geométrico, ou exponencial, tendo a forma de uma parábola. O termo "linear" também é usado no presente contexto, que está a meio caminho entre o termo matemático e o de programação. Especificamente, implementaremos uma variante MQL5 prática do dimensionamento da posição fracionária fixa desenvolvida por Ralph Vince.

Figura 1. Parábola matemática


Figura 1. Parábola matemática

Vamos fazer agora um rápido resumo dos modelos de gestão de dinheiro e ver como podemos implementar uma variante do dimensionamento de posição fracionária fixa de Ralph Vince. Você está pronto? Não perca a oportunidade de ganhar muito mais das estratégias de negociação!


1. O que são modelos de gestão de dinheiro?

Em poucas palavras, modelos de gestão de dinheiro são estruturas conceituais, sob as quais você toma decisões em relação aos seus dimensionamentos de posição, o uso de suas stop losses e seus cálculos de margem e custos de negociação. Existem muitos modelos de gestão de dinheiro lá fora! Se desejar, você pode usar o google para Fixed Lot (lote fixo), Fixed Fractional (fracionário fixo), Fixed Ratio (taxa fixa), porcentagem de Kelly ou Effective Cost (custo efetivo) para aprofundar o seu conhecimento sobre as estruturas clássicas. Como eu disse, este artigo apenas cobre uma variante do Fixed Fractional (fracionário fixo).


1.2. Fixed Fractional (fracionário fixo)

A ideia por trás desse modelo de gestão de dinheiro é a de dimensionar operações de acordo com o risco estimado associado a eles. O risco é a mesma fração da rede em cada negociação. 

A equação para o número de contratos em dimensionamento de posição fracionária fixa é a seguinte:



N = f * Lucro líquido / Risco de negociação

N é o número de contratos, f é a fração fixa (um número entre 0 e 1), Lucro líquido é o valor atual do lucro da conta e Risco de negociação é o risco de negociação por contrato para o qual está sendo calculado o número de contratos. Por favor, leia o artigo Dimensionamento de posição de Fixed Fractional (fracionário fixo) escrito por Michael R. Bryant para saber mais sobre este modelo.

Uma propriedade interessante do modelo fracionário fixo é que, desde que a dimensão das operações se mantenha proporcional ao saldo líquido da conta, é teoricamente impossível de perder todo o seu capital. O risco de ruína é zero. Por outro lado, como percentagens de capital de risco são mais baixas, uma faixa de ganho ou de perda de operações não tem um impacto dramático sobre a curva de lucro.


2. Adição de fracionário fixo ao seu sistema de negociação


2.1. Obtenha seu sistema de negociação linear

É claro que, antes de tudo, você precisa de um sistema de negociação linear para experimentar o poder exponencial de baixo risco! Este sistema servirá como base de poder, por assim dizer. Por um sistema linear, quero dizer, um sistema de negociação que prove ser um vencedor por um determinado período de tempo e cuja curva de lucro líquido pareça uma linha reta. Por exemplo, HawaiianTsunamiSurfer é um tão chamado sistema de negociação linear disponível na base de código. Sua curva de lucro líquido parece uma linha reta de janeiro de 2012 até março de 2012.

Figura 2. A curva de lucro líquido do HawaiianTsunamiSurfer de janeiro de 2012 até março de 2012

Figura 2. A curva de lucro líquido do HawaiianTsunamiSurfer de janeiro de 2012 até março de 2012

O objetivo deste artigo não é o de desenvolver um sistema de negociação linear a partir do zero, mas para dar-lhe as ferramentas necessárias para que você possa obter mais resultado dos seus sistemas. Assim, a partir de agora, vou assumir que você já desenvolveu um sistema de negociação como este sob o paradigma baseado em objetos. Neste caso, você deve adicionar a peça OO, que eu explico abaixo.

2.2. CEvolution, a classe do MQL5 de núcleo para elevar o seus sistema ao poder

Então mais uma vez pegamos a abordagem baseada em objetos para codificar nosso EA. Recomendo que você primeiro leia os artigos Uma outra classe OOP do MQL5 e Construindo um negociador de negociação automático para obter a base técnica para trabalhar esta forma OO. Se você já tiver feito isso, tenha em mente que os projetos discutidos nesses artigos incorporam um elemento muito importante chamado CEvolution. Isto permite-nos manter a par de algumas informações temporais importantes, tais como o estado do robõ em um dado momento, a história das operações realizadas, etc.

Desta vez, vamos codificar em CEvolution a lógica necessária para gerenciar o nosso dinheiro. Como a fração fixa arriscada permanece proporcional ao lucro líquido, no qual todos concordamos que não é constante, mas variável, essa coisa lógica deve ser codificada em CEvolution. Ou em poucas palavras, como o declive da curva de lucro evolui com o tempo, ele está em CEvolution onde tudo isso deve ser implementado. Esta é a ideia abstrata de nosso projeto baseado em objetos. É deixado como um exercício para você integrar a seguinte classe OO com seu sistema de negociação de estilo baseado em objetos.

Class CEvolution.mqh:

//+------------------------------------------------------------------+
//|                                                   CEvolution.mqh |
//|                               Copyright © 2013, Jordi Bassagañas |
//+------------------------------------------------------------------+
#include <Mine\Enums.mqh>
//+------------------------------------------------------------------+
//| CEvolution Class                                                 |
//+------------------------------------------------------------------+
class CEvolution
  {
protected:
   ENUM_STATUS_EA                   m_status;            // The current EA's status
   ENUM_EXP_EQUITY_CURVE_LEVEL      m_expEquityLevel;    // The current exponential equity level
   double                           m_originalEquity;    // The original equity value
   double                           m_lotSize;           // The current lot size

public:
   //--- Constructor and destructor methods
                                    CEvolution(ENUM_STATUS_EA status,ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level);
                                    ~CEvolution(void);
   //--- Getter methods
   ENUM_STATUS_EA                   GetStatus(void);
   ENUM_EXP_EQUITY_CURVE_LEVEL      GetExpEquityLevel(void);
   double                           GetOriginalEquity(void);
   double                           GetLotSize(void);
   //--- Setter methods
   void                             SetStatus(ENUM_STATUS_EA status);
   void                             SetExpEquityLevel(ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level);
   void                             SetOriginalEquity(double equity);
   void                             SetLotSize(double size);
   //--- CEvolution specific methods
   double                           CalcEquityGrowth(double currentEquity);
   void                             RefreshExpEquityLevel(double currentEquity);
   void                             RefreshLotSize();
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CEvolution::CEvolution(ENUM_STATUS_EA status,ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level)
  {
   m_status=status;
   m_expEquityLevel=exp_equity_level;
   RefreshLotSize();
   m_originalEquity=AccountInfoDouble(ACCOUNT_EQUITY);
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CEvolution::~CEvolution(void)
  {
  }
//+------------------------------------------------------------------+
//| GetStatus                                                        |
//+------------------------------------------------------------------+
ENUM_STATUS_EA CEvolution::GetStatus(void)
  {
   return m_status;
  }
//+------------------------------------------------------------------+
//| GetExpEquityLevel                                                |
//+------------------------------------------------------------------+
ENUM_EXP_EQUITY_CURVE_LEVEL CEvolution::GetExpEquityLevel(void)
  {
   return m_expEquityLevel;
  }
//+------------------------------------------------------------------+
//| GetEquity                                                        |
//+------------------------------------------------------------------+
double CEvolution::GetOriginalEquity(void)
  {
   return m_originalEquity;
  }
//+------------------------------------------------------------------+
//| GetLotSize                                                       |
//+------------------------------------------------------------------+
double CEvolution::GetLotSize(void)
  {
   return m_lotSize;
  }
//+------------------------------------------------------------------+
//| SetStatus                                                        |
//+------------------------------------------------------------------+
void CEvolution::SetStatus(ENUM_STATUS_EA status)
  {
   m_status=status;
  }
//+------------------------------------------------------------------+
//| SetExpEquityLevel                                                |
//+------------------------------------------------------------------+
void CEvolution::SetExpEquityLevel(ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level)
  {
   m_expEquityLevel=exp_equity_level;
  }
//+------------------------------------------------------------------+
//| SetEquity                                                        |
//+------------------------------------------------------------------+
void CEvolution::SetOriginalEquity(double equity)
  {
   m_originalEquity=equity;
  }
//+------------------------------------------------------------------+
//| SetLotSize                                                       |
//+------------------------------------------------------------------+
void CEvolution::SetLotSize(double lot_size)
  {
   m_lotSize=lot_size;
  }
//+------------------------------------------------------------------+
//| CalcEquityGrowth                                                 |
//+------------------------------------------------------------------+
double CEvolution::CalcEquityGrowth(double currentEquity)
  {
   return NormalizeDouble(currentEquity * 100 / m_originalEquity - 100,2);
  }
//+------------------------------------------------------------------+
//| RefreshExpEquityLevel                                            |
//+------------------------------------------------------------------+
void CEvolution::RefreshExpEquityLevel(double currentEquity)
  {
   double growth = CalcEquityGrowth(currentEquity);
   //--- is the current equity less than 10% of the original amount?
   if(growth <= 10)
   {
      SetExpEquityLevel(LEVEL_ONE);
   }
   //--- is the current equity more than 10% of the original amount and less than 20%?
   else if(growth > 10 && growth <= 20)
   {
      SetExpEquityLevel(LEVEL_TWO);
   }
   //--- is the current equity more than 20% of the original amount and less than 30%?
   else if(growth > 20 && growth <= 30)
   {
      SetExpEquityLevel(LEVEL_THREE);
   }
   //--- is the current equity more than 30% of the original amount and less than 40%?
   else if(growth > 30 && growth <= 40)
   {
      SetExpEquityLevel(LEVEL_FOUR);
   }
   //--- is the current equity more than 40% of the original amount and less than 50%?
   else if(growth > 40 && growth <= 50)
   {
      SetExpEquityLevel(LEVEL_FIVE);
   }
   //--- is the current equity more than 50% of the original amount and less than 60%?
   else if(growth > 50 && growth <= 60)
   {
      SetExpEquityLevel(LEVEL_SEVEN);
   }
   //--- is the current equity more than 60% of the original amount and less than 70%?   
   else if(growth > 60 && growth <= 70)
   {
      SetExpEquityLevel(LEVEL_EIGHT);
   }
   //--- is the current equity more than 70% of the original amount and less than 80%?   
   else if(growth > 70 && growth <= 80)
   {
      SetExpEquityLevel(LEVEL_NINE);
   }
   //--- is the current equity more than 90% of the original amount?
   else if(growth > 90)
   {
      SetExpEquityLevel(LEVEL_TEN);
   }
  }
//+------------------------------------------------------------------+
//| RefreshLotSize                                                   |
//+------------------------------------------------------------------+
void CEvolution::RefreshLotSize()
  {
   switch(m_expEquityLevel)
   {
      case LEVEL_ONE:
         SetLotSize(0.01);
         break;
         
      case LEVEL_TWO:
         SetLotSize(0.02);
         break;
         
      case LEVEL_THREE:
         SetLotSize(0.03);
         break;
         
      case LEVEL_FOUR:
         SetLotSize(0.04);
         break;
         
      case LEVEL_FIVE:
         SetLotSize(0.05);
         break;
         
      case LEVEL_SIX:
         SetLotSize(0.06);
         break;
         
      case LEVEL_SEVEN:
         SetLotSize(0.07);
         break;

      case LEVEL_EIGHT:
         SetLotSize(0.08);
         break;
         
      case LEVEL_NINE:
         SetLotSize(0.09);
         break;
         
      case LEVEL_TEN:
         SetLotSize(0.1);
         break;
   }
  }
//+------------------------------------------------------------------+

Vamos agora comentar algumas partes importantes desta classe! 

Quando o Expert Advisor é criado, o valor da curva de lucro líquido original é armazenado em m_originalEquity:

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CEvolution::CEvolution(ENUM_STATUS_EA status,ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level)
  {
   m_status=status;
   m_expEquityLevel=exp_equity_level;
   RefreshLotSize();
   m_originalEquity=AccountInfoDouble(ACCOUNT_EQUITY);
  }

O método CEvolution::CalcEquityGrowth é para calcular o crescimento da curva de lucro líquido, sempre com respeito ao seu valor original:

//+------------------------------------------------------------------+
//| CalcEquityGrowth                                                 |
//+------------------------------------------------------------------+
double CEvolution::CalcEquityGrowth(double currentEquity)
  {
   return NormalizeDouble(currentEquity * 100 / m_originalEquity - 100,2);
  }

Finalmente, o CEvolution ::RefreshExpEquityLevel é para atualizar o nível de lucro líquido em cada escala (tick) (observe como ele depende absolutamente do crescimento do lucro) e o CEvolution::RefreshLotSize é para atualizar o tamanho do lote em cada escala (tick). Isso é porque você deve atualizar essa informação em seu método OnTick do EA desta forma:

GetEvolution().RefreshExpEquityLevel(AccountInfoDouble(ACCOUNT_EQUITY));
GetEvolution().RefreshLotSize();

Por falar nisso, esta solução requer a utilização da seguinte enumeração do MQL5 personalizado:

//+------------------------------------------------------------------+
//| Exponential equity curve level enumeration                       |
//+------------------------------------------------------------------+
enum ENUM_EXP_EQUITY_CURVE_LEVEL
  {
   LEVEL_ONE,
   LEVEL_TWO,
   LEVEL_THREE,
   LEVEL_FOUR,
   LEVEL_FIVE,
   LEVEL_SIX,
   LEVEL_SEVEN,
   LEVEL_EIGHT,
   LEVEL_NINE,
   LEVEL_TEN
  };
Dizemos que esta implementação é uma variante do Fixed Fractional (fracionário fixo), pois, de fato, apresenta algumas especificações. Por exemplo, a curva de lucro líquido crescerá exponencialmente até atingir o denominado nível de dez, em seguida, o sistema irá tornar-se linear. No entanto, CEvolution mantém a ideia básica de aumentar constantemente a dimensão das posições em proporção com a curva de lucro líquido.

2.3. Tomada de decisões sobre seus Fixed Fractional (fracionários fixos)

Com tudo falado acima, você já pode tomar suas decisões de gestão de dinheiro com base no status atual do seu robõ.

Em algum local no seu método OnTick do EA:

switch(GetEvolution().GetStatus())
     {
      case BUY:

         tp = ask + m_takeProfit * _Point;
         sl = bid - m_stopLoss * _Point;

         GetTrade().PositionOpen(GetBrain().GetSymbol(),ORDER_TYPE_BUY,m_evolution.GetLotSize(),ask,sl,tp);
         
         break;

      case SELL:

         sl = ask + m_takeProfit * _Point;
         tp = bid - m_stopLoss * _Point;

         GetTrade().PositionOpen(GetBrain().GetSymbol(),ORDER_TYPE_SELL,m_evolution.GetLotSize(),bid,sl,tp);
         
         break;

      case DO_NOTHING:

         // Nothing...

         break;
     }

Coloquei outro nome no meu novo sistema exponenciado para ExponentialHawaiian.


3. Simulando o seu sistema exponenciado

Uma vez que você adicione a lógica OO explicada acima ao seu sistema, não esqueça de executar seus testes! Agora estou simulando ExponentialHawaiian, a variante do Fixed Fractional (fracionário fixo) do HawaiianTsunamiSurfer:

Figura 3. A curva de lucro líquido do ExponentialHawaiian de janeiro de 2012 até março de 2012

Figura 3. A curva de lucro líquido do ExponentialHawaiian de janeiro de 2012 até março de 2012

A curva acima permanecerá exponencial enquanto o sistema subjacente permanece linear. Quando essa condição já não é verdade, o sistema torna-se instável com um risco teórico de ruína.


Conclusão

Hoje aprendemos como obter mais lucro com os nossos sistemas de negociação lineares, aqueles implementando um modelo de gestão de dinheiro Fixed Lot, levantando-os ao poder de exponenciação.

Começamos apresentando alguns modelos de gestão de dinheiro clássicos Fixed Lot (lote fixo), Fixed Fractional (fracionário fixo), Fixed Ratio (taxa fixa), porcentagem de Kelly ou Effective Cost (custo efetivo) e decidimos nos concentrar em Fixed Fractional (fracionário fixo), um modelo simples em que a dimensão das operações se mantenha proporcional ao saldo líquido da conta. Finalmente, fizemos um sistema de negociação mostrando resultados lineares, por um período de tempo, nós implementamos em MQL5 uma variante do Fixed Fractional (fracionário fixo) e mostrou os resultados lançados pelo verificador de estratégia do MetaTrader.

Mais uma vez, pegamos a abordagem baseada em objetos para codificar os nossos Expert Advisors. É altamente recomendado que você primeiro leia os artigos Uma outra classe OOP do MQL5 e Construindo um negociador de negociação automático para obter a base técnica para trabalhar esta forma OO.

Traduzido do Inglês pela MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/en/articles/734

Arquivos anexados |
cevolution.mqh (8.35 KB)
Surpreenda seus clientes MQL5 com um coquetel prático de tecnologias! Surpreenda seus clientes MQL5 com um coquetel prático de tecnologias!

O MQL5 fornece programadores com um conjunto muito completo de funções e IPA baseado em objetos graças aos quais eles podem fazer tudo o que quiserem dentro do ambiente MetaTrader. No entanto, Tecnologia Web é uma ferramenta extremamente versátil hoje em dia que pode vir para o resgate em algumas situações quando você precisa fazer algo muito específico, seja para surpreender seus clientes com algo diferente ou simplesmente por você não ter tempo suficiente para dominar uma parte específica da Biblioteca Padrão MT5. O exercício de hoje o leva através de um exemplo prático de como você pode gerenciar a duração de desenvolvimento, ao mesmo tempo que você também cria um coquetel tecnológico incrível.

Assistente MQL5: Como ensinar um EA a abrir ordens pendentes a qualquer preço Assistente MQL5: Como ensinar um EA a abrir ordens pendentes a qualquer preço

O artigo descreve um método de modificação do código de um módulo do sinal de negociação para implementação da funcionalidade que permite que você configure ordens pendentes a qualquer distância do preço atual: podendo ser preço de abertura ou fechamento da barra anterior ou do valor da média móvel. Há uma enorme quantidade de opções. O importante é que você possa definir qualquer preço de abertura para uma ordem pendente. Esse artigo será útil para negociadores que negociam com ordens pendentes.

Indicadores técnicos e filtros digitais Indicadores técnicos e filtros digitais

Neste artigo, os indicadores técnicos são tratados como filtros digitais. Princípios de operação e características básicas de filtros digitais são explicados. Além disso, algumas formas práticas de receber o núcleo filtro no terminal do MetaTrader 5 e a integração com um analisador de espectro pronto para o uso proposto no artigo "Construção de um analisador de espectro" são considerados. As características de pulso e de espectro dos filtros digitais típicos são usadas como exemplos.

Estendendo a biblioteca padrão do MQL5 e reutilizando o código Estendendo a biblioteca padrão do MQL5 e reutilizando o código

A biblioteca padrão do MQL5 torna mais fácil a sua vida como desenvolvedor. No entanto, ela não implementa todas as necessidades de todos os desenvolvedores no mundo, então, se você achar que precisa de mais algum material de customização, você pode dar um passo a mais e estender. Este artigo o orienta através da integração do indicador técnico Zig-Zag MetaQuotes' na biblioteca padrão. Ficamos inspirados pela filosofia de design MetaQuotes' para alcançar o nosso objetivo.