Eleve os seus sistemas de negociação lineares ao poder
laplacianlab | 26 março, 2014
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
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
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
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.