Doğrusal Alım Satım Sistemlerinizi Güçlendirin

Giriş

Bugünün makalesi, orta düzeyde MQL5 programcılarının, üstünü alma tekniğinin kolayca uygulanması ile doğrusal alım satım sistemlerinden nasıl daha fazla kâr elde edebileceğini gösterir. Üst alma genel terimi, burada piyasaya girilen pozisyonların boyutunu ve sayısını kişinin aldığı riske göre düzenleyen para yönetim modellerini belirtmek için kullanılmaktadır. Bunun nedeni, elde edilen öz varlık eğrisi büyümesinin geometrik veya üstel olması ve bir parabol şeklini almasıdır. "Doğrusal" terimi de, mevcut bağlamda matematik ve programlamanın orta noktasında kullanılmaktadır. Özellikle, Ralph Vince tarafından geliştirilen Sabit Kesirli pozisyon boyutlandırmasının pratik bir MQL5 varyantını uygulayacağız.

Şekil 1. Matematik parabolü

Şimdi Para Yönetimi Modellerinin kısa bir özetini yapalım ve Ralph Vince'in Sabit Kesirli pozisyon boyutlandırmasının bir varyantını nasıl uygulayabileceğimizi görelim. Hazır mısınız? Alım satım stratejilerinizden çok daha fazlasını elde etme fırsatını kaçırmayın!

1. Para Yönetimi Modelleri nelerdir?

Para Yönetimi Modelleri, özetle, pozisyon boyutlandırmanıza, zarar durdurmaları kullanımınıza ve marj hesaplamalarınıza ve alım satım maliyetlerinize dair kararlar aldığınız kavramsal çerçevelerdir. Çok fazla Para Yönetimi Modeli vardır. Bu klasik çerçevelere dair bilginizi derinleştirmek isterseniz Sabit Lot, Sabit Kesitli, Sabit Oran, Kelly Yüzdesi veya Etkili Maliyet kelimeleri ile Google araması yapabilirsiniz. Söylediğim gibi bu makale yalnızca Sabit Kesirli modelinin bir varyantını içermektedir.

1.2. Sabit Kesirli Model

Bu para yönetimi modelinin arkasındaki fikir, işlemlerin, bunlarla ilgili tahmini riske göre boyutlandırılmasıdır. Risk, her bir alım satımda ağın aynı kesrine karşılık gelir. 

Sabit kesitli pozisyon boyutlandırmasındaki işlem sayısına yönelik denklem aşağıdaki gibidir:

N = f * Öz Varlık / Alım Satım Riski

N sözleşme sayısıdır, f sabit kesirdir (0 ile 1 arasında bir sayı), Öz sermaye hesap öz sermayesinin mevcut değeridir ve Alım Satım Riski, sözleşme sayısının hesaplandığı sözleşme başına alım satım riskidir. Bu model hakkında daha fazla bilgi edinmek için lütfen Michael R. Bryant tarafından yazılan Sabit Kesirli Pozisyon Boyutlandırma makalesini okuyun.

Sabit Kesirli modelin ilginç bir özelliği, işlemlerin boyutu hesabın net bakiyesine orantılı şekilde tutulduğundan tüm sermayenizi kaybetmeniz teorik olarak imkansızdır. İflas riski sıfırdır. Diğer yandan, risk sermaye yüzdeleri daha düşük olduğundan, kazanan veya kaybeden işlemler serisinin kâr eğrisi üzerinde büyük bir etkisi olmaz.

2. Alım Satım Sisteminize Sabit Kesirli Modeli Ekleme

2.1. Doğrusal Alım Satım Sisteminizi Alın

Elbette, ilk olarak düşük riskli üstel gücü deneyimlemek için bir doğrusal alım satım sistemine ihtiyacınız var. Bu sistem, deyim yerindeyse güç tabanı görevi görür. Bir doğrusal sistem ile, belirli bir zaman periyodu boyunca kazandığı kanıtlanan ve öz varlık eğrisi düz bir çizgi şeklinde görünen bir alım satım sisteminden bahsediyorum. Örneğin, HawaiianTsunamiSurfer Code Base içinde bulunan bir doğrusal alım satım sistemidir. Bunun öz varlık eğrisi Ocak 2012 ila Mart 2012 arasında düz bir çizgi şeklinde görünmektedir.

Şekil 2. Ocak 2012 ila Mart 2012 HawaiianTsunamiSurfer öz varlık eğrisi

Bu makalenin amacı, sıfırdan bir doğrusal alım satım sistemi oluşturmak değil, sistemlerinizden daha fazla faydalanabilmeniz için size gerekli araçları sağlamaktır. Şu andan itibaren, nesne yönelimli paradigma kapsamında buna benzer bir alım satım sistemini halihazırda geliştirdiğinizi varsayacağım. Bu durumda aşağıda açıkladığım OO parçasını eklemelisiniz.

2.2. CEvolution, Sisteminizi Güçlendirmeniz İçin Core MQL5 Sınıfı

EA'mızı kodlamak için bir kez daha nesne yönelimli yaklaşımı benimseyeceğiz. Bu OO şekli ile çalışmak üzere teknik temel oluşturmak üzere ilk olarak Bir Diğer MQL5 OOP sınıfı ve Bir Otomatik Haber Yatırımcısı Oluşturma makalelerini okumanızı tavsiye ederim. Bunu zaten yaptıysanız, bu makalelerde tartışılan tasarımların CEvolution olarak adlandırılan çok önemli bir öğe olduğunu aklınızdan çıkarmayın. Bu, robotun belirli bir andaki durumu, gerçekleştirilen işlemlerin geçmişi vb. gibi geçici bilgileri takip etmemize olanak sağlar.

Şimdi ise, paramızı yönetmemiz için gereken mantığı CEvolution içine kodlayacağız. Riske edilen sabit kesit öz varlık ile orantılı olduğundan, burada bunun sabit değil değişken olduğunda hemfikiriz, bu mantık öğeleri CEvolution içine kodlanmalıdır. Veya basitçe ifade etmek gerekirse, öz varlık eğrisinin eğimi zamanla evrilirken, tüm öğelerin uygulanmasının gerektiği CEvolution içinde bulunur. Bu, nesne yönelimli tasarımının soyut fikridir. Aşağıdaki OO sınıfının nesne yönelimli stilde alım satım sisteminiz ile entegre edilmesi size alıştırma olarak bırakılmıştır

Sınıf 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;
   }
  }
//+------------------------------------------------------------------+

Şimdi bu sınıfın bazı önemli kısımlarına dair yorumlarda bulunalım. 

Uzman Danışman oluşturulduğunda, orijinal öz varlık eğrisinin değeri m_originalEquity içinde saklanır:

//+------------------------------------------------------------------+
//| 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);
  }

CEvolution::CalcEquityGrowth yöntemi, her zaman bunun orijinal değerine göre, öz varlık eğrisinin büyümesinin hesaplanmasına yöneliktir:

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

Son olarak, CEvolution::RefreshExpEquityLevel, her tikte öz varlık değerinin yenilenmesine yöneliktir (bunun nasıl mutlak surette öz varlık büyümesine bağlı olduğunu gözleyin) ve CEvolution::RefreshLotSize, her tikte lot boyutunun yenilenmesine yöneliktir. Bunun nedeni, bu bilgileri EA'nızın OnTick yönteminde bu şekilde yenilemenizin gerekmesidir:

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

BU arada bu çözüm, aşağıdaki özel MQL5 numaralandırmasının kullanımını gerektirmektedir:

//+------------------------------------------------------------------+
//| 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
  };

Bu uygulamanın, aslında bazı özellikleri tanıttığı için Sabit Kesirli Modelin bir varyantı olduğunu söyleriz. Örneğin öz varlık eğrisi, on seviyesine ulaşıncaya kadar üstel olarak büyüyecektir ve ardından sistem doğrusal olacaktır. Ancak, CEvolution, pozisyonların boyutunu öz varlık eğrisi ile orantılı olarak sürekli olarak arttırma temel fikrini sürdürür.

2.3. Sabit Kesirli Model Kararı Alma

Yukarıdakilerin tamamı göz önüne alındığında, robotunuzun mevcut durumuna göre para yönetimi kararlarınızı zaten alabilirsiniz.

EA'nızın OnTick yönteminin bir bölümünde:

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;
     }

Yeni üstel sistemimi ExponentialHawaiian olarak yeniden adlandırdım.

3. Üstel sisteminizi geriye dönük test etme

Yukarıda açıklanan OO mantığını sisteminize ekledikten sonra testlerinizi çalıştırmayı unutmayın! Şimdi ben HawaiianTsunamiSurfer'ın Sabit Kesitli varyantı olan ExponentialHawaiian'ı geriye dönük test edeceğim:

Şekil 3. Ocak 2012 ila Mart 2012 ExponentialHawaiian öz varlık eğrisi

Yukarıdaki eğri, alttaki sistem doğrusal kalırken üstel kalmaktadır. Bu durum artık doğru olmadığında sistem teorik bir iflas riskinden dolayı kararsız hale gelmektedir.

Sonuç

Bugün, üst alma gücüne yükselterek doğrusal alım satım sistemlerimizden nasıl daha fazla kâr elde edeceğimizi ve Sabit Lot para yönetimi modelini uygulayanları öğrendik.

Bazı klasik para yönetimi modellerini (Sabit Lot, Sabit Kesitli, Sabit Oran, Kelly Yüzdesi, Etkili Maliyet) açıklayarak başladık ve işlemlerin boyutunun hesabın net bakiye orantılı tutulduğu basit bir model olarak Sabit Kesitli Modele odaklanmaya karar verdik. Son olarak, bir periyot boyunca doğrusal sonuçlar gösteren bir alım satım sistemini aldık, MQL5'e Sabit Kesitli Modelin bir varyantını uyguladık ve MetaTrader Strateji Test Cihazı tarafından sunulan sonuçları gördük.

Uzman Danışmanlarımızı kodlamak için bir kez daha nesne yönelimli yaklaşımı benimsedik. Bu OO şekli ile çalışmak üzere teknik temel oluşturmak üzere ilk olarak Bir Diğer MQL5 OOP sınıfı ve Bir Otomatik Haber Yatırımcısı Oluşturma makalelerini okumanızı şiddetle tavsiye ederim.