MQL5'te kantitatif analiz: Başarılı bir algoritmanın uygulanması

Finans piyasasında kantitatif analiz nedir?

Finans piyasasında kantitatif analiz nedir? Kantitatif analiz, aslında istatistiksel öğrenmenin bir alt bölümü olan makine öğreniminin bir tür öncüsü olarak ortaya çıkmıştır. Bilgisayarların yeni yeni ortaya çıkmaya başladığı, bütün bir odayı kapladığı ve delikli kartlarla çalıştığı günlerde, ileri görüşlü beyinler onları büyük veri ve istatistikleri analiz etmek için uyarlamaya çalışıyordu. O zamanlar fiyatların çalıştırılabileceği istatistiksel işlemler ve fonksiyonlar kümesi son derece küçüktü, fonksiyonların kendileri oldukça basitti ve bulunan modeller pek de karmaşık değildi.

Bu çalışmalar, çoğunlukla doğrusal olan verilerdeki belirli ilişkileri tanımlamak için yapılan basit hesaplamalardı.

Finansal piyasalarda kantitatif analizin en basit ve öğrenmesi en kolay yöntemi, ilgili varlıklar arasındaki makasın analizidir. Örneğin, iki korelasyonlu varlık arasında bir makas grafiği çizebilir ve kantitatif analiz kullanarak bu makasın ortalama, maksimum ve medyan sapmasını bulabiliriz. Verilerin kantitatif bir tanımını elde ettikten sonra, bir varlığın diğerinden ne kadar saptığını anlayabilir ve aralarındaki tutarsızlık ortadan kalktığında (varlıklar birbirine doğru hareket ettiğinde) her ikisinin de kesinlikle geri döneceği iki varlığın denge durumunu kabaca anlayabiliriz. Genel olarak, ikili işlemde (pairs trading) kantitatif analiz kullanımı çok ilginç bir konudur; gelecek makalelerde kesinlikle bu noktaya değineceğiz. 

Kantitatif analiz hedge fonlar tarafından nasıl kullanılıyor?

Kantitatif analizi kullanmaya yönelik ilk girişim, 1970'lerde bir hisse senedi ile o hisse senedinin varantı arasındaki makası analiz etmeyi öğrenen ve varlığın varantına göre ne kadar fazla değerli veya az değerli olduğunu hesaplayan Edward O. Thorp'un uygulamasıydı. Thorp'un bilgisayarı o zamanlar bütün bir odayı kaplıyordu ve delikli kartlarla çalışıyordu. Edward O. Thorp genel olarak bilgisayarlı kantitatif analizi finansal piyasalara uygulayan ilk kişidir. Bu, tüm dünya tarafından tanınan, o zamanın çığır açan bir buluşuydu. Thorp dünyanın ilk "kantitatif" hedge fonunu yarattı. 

Sizin de anladığınız gibi, borsada kantitatif analizin aklımıza gelen ilk örneği, ikili işlem (pairs trading) veya sepet işlemindeki (basket trading) uygulamasıdır. Bu seçenekleri kesinlikle değerlendireceğiz, ancak bugün kantitatif analiz algoritmamız başka ilkelere dayanacaktır.

Büyük piyasa katılımcıları kantitatif analizi başka nasıl kullanıyor? 

İstatistiksel arbitraj, farklı piyasalardaki veya farklı zaman noktalarındaki finansal enstrümanların fiyatlarındaki farklılıkları tespit etmelerini sağlar. Bu, fonların çeşitli ilişkili piyasalarda kârlı işlem fırsatlarını tespit etmesine ve bunlardan yararlanmasına olanak tanır. Ayrıca kantitatif modeller, hedge fonların istatistiksel verilere dayanarak gelecekteki piyasa hareketlerini tahmin etmelerine yardımcı olarak bilinçli alım-satım kararları almalarına yardımcı olur.

Risk yönetimi, kantitatif analizin bir diğer son derece önemli uygulamasıdır. Hedge fonlar, portföylerindeki riski değerlendirmek ve yönetmek için modeller kullanır. Potansiyel kayıpları en aza indirmek için varlık yapısını riske göre optimize ederler. Bunun Markowitz portföy teorisine göre portföy optimizasyonu (portföyün sapmasının potansiyel kârı aşmaması için riske dayanır) ve VaR sistemine göre risk yönetimi gibi farklı örnekleri vardır. İkincisi, %99 ihtimalle aşmayacağımız düşüşü hesaplamamıza olanak tanıyan benzersiz bir modeldir.

Elbette, gerçek piyasayı matematik kullanarak tanımlamak bazen oldukça zordur, bu nedenle olumsuz örnekler de vardır. 1998'de LTCM hedge fonu, pozisyonlarının büyük bir zarar getirmeyeceğini hesapladı ve kantitatif analize dayalı olarak uzun vadeli ve yakın vadeli ABD tahvilleri arasındaki farkı hedefleyen bir arbitraj stratejisine girdi. Rusya temerrüde düştü, Asya kriz yaşadı ve sonuç olarak bu durum kelebek etkisi yoluyla ABD devlet tahvili piyasasında paniğe yol açtı. LTCM fonu, makasın anormal derecede yüksek olduğunu, fiyatın kesinlikle ters yönde "geri döneceğini" ve fonun pozisyonlarının kesinlikle kârla kapatılacağını öne süren modeller kullandı.

Sonuç olarak, fon ortalama alma (averaging) uyguladı, aşırı agresif bir şekilde yüksek bir kaldıraç kullandı, varlıklarla borca yüklendi ve şirketin kadrosundaki Nobel ödüllü kişiler böyle bir sonucun imkansızlığından bahsetmesine rağmen battı. VaR kantitatif analiz modeli neredeyse tüm ABD piyasasını mahvetti. Fed Başkanı Alan Greenspan, fonun teminatlı pozisyonlarını satın almaları için ABD'nin en büyük bankalarının yöneticilerini acilen çağırmak zorunda kaldı, aksi takdirde bu kadar büyük bir varlık havuzunun "piyasaya" satılması, ABD borsasının derhal sıfırlanmasına ve Büyük Buhran'dan daha kötü bir paniğe neden olacaktı.

Bu nedenle, kantitatif analiz ve herhangi bir göstergenin ortalama almasını uygularken, normal olasılık dağılımının kuyruklarını hatırlamak önemlidir. Çan şeklindeki olasılık eğrisi, finansal piyasalar söz konusu olduğunda, "siyah kuğular" (black swans) olarak da adlandırılan önemli sapmaları yansıtan "şişman kuyruklara" (fat tails) sahiptir. Bir yandan istatistiksel olarak son derece düşük ihtimalli olan bu olayların ölçeği ve gücü yatırımcıların portföylerini ve hedge fon portföylerini yok edebilir, teminatlı pozisyonları ortadan kaldırabilir, piyasaları tahrip edebilir ve her yeni döngüde onları değiştirebilir. Bunu 1998, 2008, 2020 ve 2022 yıllarında gördük. Dahası, bunu gelecekte birçok kez göreceğiz.

Kantitatif analiz, hedge fonlara oldukça fazla şey verir ve günlük işlerinde sürekli olarak kullanırlar. Ancak milyonlarca insanın kararlarını, paniklerini ve belirli olaylara tepkilerini hesaplayabilecek böyle bir fonksiyonun olmadığını unutmamak önemlidir. Agresif alım-satım taktikleri kullanıldığında bakiyeyi yok edebilecek normal dağılımın kuyruklarını hatırlamak da önemlidir. 

Algoritmanın temeli: Hareket dalgalarını sayma

Fikrimizin temeli ilk olarak, bir varlığın kendisine göre ne kadar fazla değerli veya az değerli olduğunu anlamak için fiyat hareketi dalgalarının boyutunu hesaplayan yatırımcı Artem Zvezdin tarafından ifade edildi. Örneğin, fiyatın küçük döngülerinin her birinde ne kadar ilerlediğini anlamak için son 500-5000 çubuktaki yükseliş ve düşüş dalgalarını sayıyoruz. Her fiyat hareketi döngüsü birilerinin pozisyonlarını, birilerinin parasını ve birilerinin alış ya da satış kararlarını yansıtır. Her yeni döngü, piyasanın yeni bir doğumu ve ölümüdür. Fiyat hareketlerini geri dönüşler olmadan, yukarıdan aşağıya doğru analiz etme fikrini kullanacağız. Bu, yaklaşık olarak aynı şekilde hareket eden ayrı bir katılımcı grubudur, bu nedenle döngülerin uzunluğunun her zaman kabaca aynı olacağını varsayıyoruz. Standart MetaTrader 5 terminal paketine dahil olan ZigZag göstergesini kullanarak ortalama fiyat hareketini hesaplayacağız.

Bu makalenin bir parçası olarak oluşturduğum Uzman Danışmana bakalım. İlk olarak, Uzman Danışmanın başlık kısmına bir göz atalım. Buradaki ayarlar oldukça basittir. Alım-satım için standart Trade kütüphanesini kullanıyoruz. Lot ayarı için, sabit bir lotta işlem yapmak için bir lot veya bakiye değerine dayalı lot hesaplaması belirleyebilirsiniz. 0'dan büyük bir kapanış kârı belirtirseniz, Uzman Danışman toplam kâra göre işlemleri kapatacaktır. Zararı Durdur ve Kârı Al, ATR değerine, yani enstrümanın mevcut volatilitesine bağlı olarak hesaplanır. Uzman Danışmanın hesaplamaları için ZigZag ayarları genellikle standarttır; bunların üzerinde durmayacağız. Ayrıca, Uzman Danışman şablonumuzun çok dövizli olduğunu ve çeşitli varlıklar üzerinde çalışabildiğini lütfen unutmayın. Uzman Danışmanın gelecekteki sürümlerinde ilişkili varlıklardan oluşan sepetlerle işlem yaparak genel riski azaltmak için buna ihtiyacımız var. Mevcut 0.90 sürümü yalnızca bir sembol üzerinde çalışacaktır.

//+------------------------------------------------------------------+
//|                                          QuantAnalysisSample.mq5 |
//|                                                   Copyright 2023 |
//|                                                Evgeniy Koshtenko |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2023, Evgeniy Koshtenko"
#property link        "https://www.mql5.com"
#property version     "0.90"
#property strict

#include <Trade\Trade.mqh>
#include <Graphics\Graphic.mqh>
#include <Math\Stat\Normal.mqh>
#include <Math\Stat\Math.mqh>
CTrade trade;
//--- Inputs
input double Lots       = 0.1;      // lot
input double Risk       = 0.1;     // risk
input double Profit     = 0;     // profit
input int StopLoss      = 0;        // ATR stop loss
input int TakeProfit    = 0;        // ATR take profit
input string Symbol1    = "EURUSD";
input int    Magic      = 777;    // magic number
//--- Indicator inputs
input uint   InpDepth       =  120;   // ZigZag Depth
input uint   InpDeviation   =  50;    // ZigZag Deviation
input uint   InpBackstep    =  30;    // ZigZag Backstep
input uchar  InpPivotPoint  =  1;    // ZigZag pivot point
datetime t=0;
double last=0;
double countMovements;
double currentMovement;
// Global variable for storing the indicator descriptor
int zigzagHandle;

Şimdi Uzman Danışmanın geri kalan fonksiyonlarına bakalım. Başlatma ve sonlandırma fonksiyonları genellikle basit ve anlaşılabilirdir. Uzman Danışmanın emirlerini diğerlerinden ayırt etmesini sağlayacak benzersiz bir tanımlayıcı olan Uzman Danışmanın sihirli numarasını ayarlıyoruz. Aynı zamanda, tanıtıcıyı kendi yazdığımız ek bir fonksiyonda ayarlıyoruz, çünkü OnInit aracılığıyla doğrudan bir çok dövizli tanıtıcı yüklersek, Uzman Danışman bir hata verecektir. Bu yüzden bu oldukça basit ve kolay çözümü kullanıyoruz.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   trade.SetExpertMagicNumber(Magic);
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert initialization function custom                            |
//+------------------------------------------------------------------+
int OnIniti(string symb)
  {// Loading the ZigZag indicator
   zigzagHandle = iCustom(symb, _Period, "ZigZag", InpDepth, InpDeviation, InpBackstep, InpPivotPoint);
   if (zigzagHandle == INVALID_HANDLE)
     {
      Print("Error loading the ZigZag indicator: ", GetLastError());
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Comment("");
  }

Uzman Danışmanın diğer fonksiyonlarına bakalım. Tüm pozisyonlardaki toplam kârı hesaplamak ve tüm emirleri tamamen kapatmak için fonksiyonlara sahibiz:

//+------------------------------------------------------------------+
//|  Position Profit                                                 |
//+------------------------------------------------------------------+
double AllProfit(int type=-1)
  {
   double p=0;

    for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         if(PositionGetInteger(POSITION_MAGIC)==Magic)
           {
            if(PositionGetInteger(POSITION_TYPE)==type || type==-1)
               p+=PositionGetDouble(POSITION_PROFIT);
           }
        }
     }

   return(p);
  }
//+------------------------------------------------------------------+
//|   CloseAll                                                       |
//+------------------------------------------------------------------+
void CloseAll(int type=-1)
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         if(PositionGetInteger(POSITION_MAGIC)==Magic)
           {
            if(PositionGetInteger(POSITION_TYPE)==type || type==-1)
               trade.PositionClose(PositionGetTicket(i));
           }
        }
     }
  }

Daha sonra, lot hesaplama fonksiyonuna ve açık pozisyon sayısını hesaplama fonksiyonuna sahibiz:

//+------------------------------------------------------------------+
//|     CountTrades                                                  |
//+------------------------------------------------------------------+
int CountTrades(string symb)
  {
   int count=0;

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         if(PositionGetString(POSITION_SYMBOL)==symb)
           {
            count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|     Lot                                                          |
//+------------------------------------------------------------------+  
double Lot()
  {
   double lot=Lots;

   if(Risk>0)
      lot=AccountInfoDouble(ACCOUNT_BALANCE)*Risk/100000;

   return(NormalizeDouble(lot,2));
  }

Ayrıca alış ve satışlar için son işlem fiyatını hesaplayan fonksiyonlarımız (daha sonra kullanacağız) ve pozisyonun yönünü belirleyen bir fonksiyonumuz var.

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double FindLastBuyPrice(string symb)
  {
   double pr=0;

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)) && PositionGetInteger(POSITION_TYPE)==0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symb)
           {
            pr=PositionGetDouble(POSITION_PRICE_OPEN);
            break;
           }
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double FindLastSellPrice(string symb)
  {
   double pr=0;

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)) && PositionGetInteger(POSITION_TYPE)==1)
        {
         if(PositionGetString(POSITION_SYMBOL)==symb)
           {
            pr=PositionGetDouble(POSITION_PRICE_OPEN);
            break;
           }
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//|  PositionType                                                    |
//+------------------------------------------------------------------+
int PositionType(string symb)
  {
   int type=8;

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         if(PositionGetString(POSITION_SYMBOL)==symb)
           {
            type=(int)PositionGetInteger(POSITION_TYPE);
            break;
           }
        }
     }
   return(type);
  }

Ve tabii ki en önemli fonksiyonumuz ortalama ve mevcut hareketi hesaplama fonksiyonudur. Kolaylık sağlamak için puan olarak değil, fiyat biriminin hareket miktarı olarak hesaplanırlar. Çok basit: "özel başlatmamızı" çağırıyoruz, arabellekleri kopyalıyoruz ve for döngüsünde ZigZag'ın tepesinden son ekstremumuna kadar olan fiyat hareketinin boyutunu hesaplıyoruz. Fonksiyon, fiyat hareketi birimi cinsinden mevcut hareketi ve ortalama hareketi çıktı olarak verir. 

//+------------------------------------------------------------------+
//|     CalculateAverageMovement                                     |
//+------------------------------------------------------------------+ 
void CalculateAverageMovement(string symb, double &averageMovement, double &currentMovement) {
    const int lookback = 500; // Number of bars for analysis
    double sumMovements = 0.0;
    int countMovements = 0;
    double lastExtremePrice = 0.0;
    double zigzagArray[500]; // Array to store ZigZag values
    OnIniti(symb);
    // Copy ZigZag values to array
    if (CopyBuffer(zigzagHandle, 0, 0, lookback, zigzagArray) <= 0) {
        Print("Error copying indicator data");
        averageMovement = -1;
        currentMovement = -1;
        return;
    }

    // Copy ZigZag values to array
    if (CopyBuffer(zigzagHandle, 0, 0, lookback, zigzagArray) <= 0) {
        Print("Error copying indicator data");
        averageMovement = -1;
        currentMovement = -1;
        return;
    }

    for (int i = 0; i < lookback; i++) {
        if (zigzagArray[i] != 0 && zigzagArray[i] != lastExtremePrice) {
            if (lastExtremePrice != 0) {
                // Determine the movement direction
                double movement = zigzagArray[i] - lastExtremePrice;
                sumMovements += movement;
                countMovements++;
            }
            lastExtremePrice = zigzagArray[i];
        }
    }

    // Calculate the current movement
    double lastMovement = iClose(symb, _Period, 0) - lastExtremePrice;
    currentMovement = lastMovement;

    // Calculate the average movement
    averageMovement = countMovements > 0 ? sumMovements / countMovements : 0.0;

    // Print the result
    Print("Average movement: ", averageMovement);
    Print("Current movement: ", currentMovement);

    // Release resources
    IndicatorRelease(zigzagHandle);
}

Anahtar fonksiyonlar arasında yer alan bir diğer fonksiyon da, mevcut fiyat hareketinin ortalama değeri aştığını gösteren sinyallere dayalı çok dövizli alım-satım fonksiyonudur. Kârı Al ve Zararı Durdur ATR'a göre belirlenir. Ayrıca, grid adımları (ortalama alma/averaging) için de ATR kullanılır. İşlemler yeni çubuklarda açılır. Bu bizim için önemli. Bu fonksiyon daha sonra OnTick içinde çağrılır ve bir ya da birkaç sembol üzerinde çalışır. Uzman Danışmanı henüz birkaç sembol üzerinde başarılı bir şekilde çalıştıramadım, daha önce de söylediğim gibi, Uzman Danışmanın başlatıldığı yalnızca bir sembol kullanacağım. Bu sembol Uzman Danışman ayarlarında belirtilmelidir. 

//+------------------------------------------------------------------+
//| Expert Trade unction                                             |
//+------------------------------------------------------------------+
void Trade(string symb)
  {
   double averageMovement = 0;
   double currentMovement = 0;
   double pr=0,sl=0,tp=0,hi=0,lo=0;
// Call function for calculation
   CalculateAverageMovement(symb, averageMovement, currentMovement);

// Use results
   double Ask = SymbolInfoDouble(symb, SYMBOL_ASK);
   double Bid = SymbolInfoDouble(symb, SYMBOL_BID);
   int dg=(int)SymbolInfoInteger(symb,SYMBOL_DIGITS);
   double pp=SymbolInfoDouble(symb,SYMBOL_POINT);
  
   double atr = iATR(symb, PERIOD_CURRENT, 3);
     
// Here define your logic for buying and selling
   bool sell  = currentMovement > -averageMovement; // Buy condition
   bool buy = -currentMovement > averageMovement; // Sell condition
  
   if(AllProfit()>Profit && Profit>0)
      CloseAll();

   if(t!=iTime(symb,PERIOD_CURRENT,0))
     {
      if(buy && CountTrades(symb)<1)
        {
         if(StopLoss>0)
            sl=NormalizeDouble(Bid-(atr*StopLoss)*Point(),_Digits);
         if(TakeProfit>0)
            tp=NormalizeDouble(Bid+(atr*TakeProfit)*Point(),_Digits);
         pr=NormalizeDouble(Bid,dg);
         trade.Buy(Lot(),symb,pr,sl,tp,"");
         last=pr;
        }
      if(sell && CountTrades(symb)<1)
        {
         if(StopLoss>0)
            sl=NormalizeDouble(Ask+(atr*StopLoss)*Point(),_Digits);
         if(TakeProfit>0)
            tp=NormalizeDouble(Ask-(atr*TakeProfit)*Point(),_Digits);
         pr=NormalizeDouble(Ask,dg);
         trade.Sell(Lot(),symb,Ask,sl,tp,"");
         last=pr;
        }
      if(CountTrades(symb)>0)
        {
         if(PositionType(symb)==0 && (FindLastBuyPrice(symb)-Ask)/pp>=atr*30)
           {
            if(StopLoss>0)
               sl=NormalizeDouble(Bid-(atr*StopLoss)*Point(),_Digits);
            if(TakeProfit>0)
               tp=NormalizeDouble(Bid+(atr*TakeProfit)*Point(),_Digits);
            trade.Buy(Lot(),symb,Ask,sl,tp);
           }
         if(PositionType(symb)==1 && (Bid-FindLastSellPrice(symb))/pp>=atr*30)
           {
            if(StopLoss>0)
               sl=NormalizeDouble(Ask+(atr*StopLoss)*Point(),_Digits);
            if(TakeProfit>0)
               tp=NormalizeDouble(Ask-(atr*TakeProfit)*Point(),_Digits);
            trade.Sell(Lot(),symb,Bid,sl,tp);
           }
        }
      t=iTime(symb,0,0);
     }
  }

Modelin test edilmesi

Sıra geldi eğlenceli kısma: modelimizi gerçek piyasada test edeceğiz. Lütfen döngü tabanlı hesaplamaların oldukça işlemci yoğun olduğunu unutmayın, bu nedenle Uzman Danışmanı yalnızca açılış fiyatlarında çalıştırmak daha mantıklıdır. EURUSD, açılış fiyatları, H1 zaman dilimi, 1 Ocak 2020'den 6 Aralık 2023'e bir test gerçekleştirelim:

Test kârlıdır, ancak düşüş yüksektir. Hiç kimse işlem yaparken ekstra risk almak istemez. Kâra dayalı bir kapanışımız olduğunu da unutmayın. Netting hesabı üzerinde bir test yapabiliriz.

Kâra dayalı kapanışla bir test çalıştırmak için kapanışı 0'ın üzerinde bir kârla ayarlayalım. Test etmeyi deneyelim. Belki istikrarlı bir test elde edebiliriz. Uzman Danışmanı aynı varlık üzerinde açılış fiyatlarıyla çalıştıralım. Hesap türümüz hedging. Ve gördüğümüz şey şu:

Uzman Danışmanın ortalama alma (averaging) nedeniyle son derece riskli olduğu ortaya çıktı. Aynı testi bir netting hesabı üzerinde çalıştırmayı deneyelim.

Yine büyük bir düşüşümüz var; kâr tamamen riske değmez. Kodu gözden geçirmeyi deneyelim. Bu kez bir sinyale göre kapatma uygulayacağız (bir yükseliş sinyali bir düşüş sinyaline dönüştüğünde, önceki pozisyonlar kapatılacaktır). Aşağıdaki kodu kullanarak kâra göre kapanış ekliyoruz:

if (CloseSig)
   {
      if (buy)
         CloseAll(1);
      if (sell)
         CloseAll(0);
   }

Ve bu ayarı ekleyelim:

input bool CloseSig     = 1;        // close by signal

Testi tekrarlayalım. Sonuçlar yine iyi değil:

Testlerin genel olarak ideal olduğu söylenemez. Düşüş çok büyük, hem netting hem de hedging hesaplarında büyük düşüşler var. Ayrıca, bir sinyale dayalı olarak kapanış yapmak herhangi bir olumlu sonuç getirmiyor ve genellikle kârsızdır. Bu oldukça üzücü.

Sonuç

MQL5'te temel ve basit bir kantitatif analiz algoritması oluşturmanın basit bir örneğini inceledik. Fiyat hareketi dalgalarını saydık, bunları ortalama değerlerle karşılaştırdık ve bu verilere dayanarak alış veya satış kararı verdik. Ne yazık ki bu, fikrin temeli oldukça iyi olmasına rağmen zarar eden bir algoritma ile sonuçlandı. Gelecek makalelerde kantitatif analizi incelemeye devam edeceğiz.