Sıfırdan bir ticaret Uzman Danışmanı geliştirme (Bölüm 13): Zaman ve ticaret (II)

Giriş

Bir önceki "Zaman ve ticaret (I)" makalesinde, piyasada gerçekleştirilen işlemleri mümkün olan en hızlı şekilde yorumlayabilmek amacıyla alternatif bir grafik sistemini ele almıştık. Ancak sistemi henüz tamamlamış değiliz: hala belirli bilgileri gösterme yeteneğinden yoksundur, ki bu bilgiler, piyasada tam olarak neler olup bittiğini anlamamız konusunda bize yardımcı olacaktır. Bu tür bilgiler doğrudan grafik üzerinde sunulamaz. Aslında böyle bir sunum uygulanabilir, ancak yorumlama çok kafa karıştırıcı olacaktır. Bu nedenle, verilerin klasik bir şekilde, yani metin biçimindeki değerlerle sunulması en iyisidir. Şu anda Uzman Danışmanımız bu görevi yerine getirebilecek özelliğe sahip değildir. Bunu uygulamamız gerekmektedir.

Bazı okuyucuların hiç ihtiyaç duymayabileceği bilgileri ekleyerek önceki makaleyi karmaşıklaştırmamak adına (sistem bu tür ayrıntılara girmeden de kullanılabileceğinden), sistemi bu makalede genişletmeye ve daha eksiksiz hale getirmeye karar verdim. Hadi başlayalım.

Planlama

Burada bir şeyi anlamak önemlidir. Bu bilgiler ayrıntıdır, ancak şeytan ayrıntıda gizlidir. O halde aşağıdaki görüntüye bir göz atalım:

Bu görüntüde tuhaf bir şey fark ettiniz mi? Pek bir anlam ifade etmiyor gibi, ama orada, çok daha dikkatli bakın.

Hala fark etmediyseniz, aşağıdaki vurgulanan alana bakın.

Şimdi neler olduğunu anlıyor musunuz? Hem alış hem de satış fiyatında değişiklikler oldu, ancak yalnızca bir işlem gerçekleşti. Sadece alış veya satış fiyatında değişikliklikler olsa bile tek bir işlemin olması mantıklı değil gibi görünüyor, öyle değil mi? Ancak bu tür şeyler aslında düşünüldüğünden daha yaygındır. Aşağıda gösterilen okuma modu kullanıldığında bunlar genellikle anlaşılamaz:

Analizi bu şekilde yaparken, alış ve satış fiyatı hareketlerini göremiyoruz. Piyasa her zaman çalışıyor, herkes işlem gerçekleştiriyor gibi görünüyor, ancak bu doğru değildir. Aslında olan şey, piyasa oyuncularının belirli noktalara pozisyonlarını yerleştirmesi ve piyasa hareketini beklemesidir. Fiyat pozisyona ulaştığında, fiyat hareketinden avantaj sağlamaya, yani kâr elde etmeye çalışırlar - dolayısıyla, alış ve satış fiyatları çoğunlukla herhangi bir işlem olmadan da hareket eder. Bu, platformda görülebilen gerçek bir olgudur, ancak çoğu kişi bu bilginin çok önemli olmadığını düşündüğü için görmezden gelir.

Zaman ve ticaret sistemimizin nasıl göründüğüne bakalım:

Dikkatli bakarsanız, grafikte dört mum konfigürasyonu olduğunu göreceksiniz. Aslında beş tane olması gerekir, ancak doğrudan emirler piyasayı fiilen hareket ettirmedikleri için sistemden çıkarılmıştır. Dolayısıyla şu dört konfigürasyona sahibiz:

Mumun gövdesi bazen gölgeye değmez. Bu neden oluyor? Gölge, spread değeri tarafından oluşturulur, yani alış ve satış fiyatı arasındaki farktır, peki bu spread içerisinde bir işlem gerçekleşirse, mum neye benzeyecektir? Bu, aşağıdaki beşinci tür olacaktır:

Bu bir doğrudan emir mumudur. Az önce bahsettiğim nedenden dolayı bu mumlar sistemde gösterilmeyecektir. Peki mumun gövdesinin gölgenin dışarısında olma durumu nasıl gerçekleşiyor? Bu tür davranışlar, fiyatın çok hızlı hareket etmesine neden olan bir şeyin olduğu durumlarla ilişkilidir. Sistemsel bir hata olduğu, fiyatın bunu yapmasının mantıklı olmadığı düşünülebilir. Ancak mantıklıdır, çünkü bu tam olarak stop emirleri tetiklendiğinde gerçekleşir. Bunu görmek için aşağıdaki görüntüye bakalım:

Alış veya satış fiyatına temas etmeyen emirlerin var olduğu görülmektedir. Tüm bu noktalar tetiklenmiş stop emirleridir. Tetiklenme sırasında fiyat sıçrar, bu, fiyat grafiğinden görülebilir. Bu durum bant analizinde yalnızca grafik modu kullanılıyorsa anlaşılabilir. Aksi takdirde, stopların tetiklendiğini görmezsiniz ve hareketin güç kazandığını düşünebilirsiniz, ancak fiyat aslında hızlıca geri dönebilir.

Artık bunu bildiğinize göre, gövdesi gölgeye dokunmayan mumların tetiklenen stop emirleri olduğunu anlayacaksınız. Bu hareketlerin piyasa için ne ifade ettiğini konusunda detaya girmeyeceğim. Ancak bant okumayı gerçekten bir gösterge olarak kullanmak istiyorsanız, bu konu odaklanmanız gereken bir konudur.

Şimdi şu soruya gelelim: Eğer ilgili bilgiler sadece mumlar kullanılarak görülebiliyorsa, mumların kendileri ek bilgileri edinmek için yeterliyse, o zaman daha fazla veriye sahip olmak neden bu kadar gerekli?

Büyük ayrıntı şu ki, piyasanın daha yavaş olduğu zamanlar mevcuttur. Bu durumlarda zaman ve ticaret sisteminin sadece mumlarıyla piyasadan fikir edinmek zorlaşabilir. Daha fazlasına ihtiyacımız vardır. Veriler, daha kolay analiz edilebilmeleri için modellenmelidir.

Bu makaleyi yazmamın nedeni de bu modellemedir. Bu modelleme sonrasında zaman ve ticaret sistemimiz şu şekilde görünecektir:

Başka bir deyişle, neler olup bittiğine dair tam resme sahip olacağız. Böylece, sistemimizin kullanışlılığı artacak, ki bu da bant okumayı ticaret yapmanın bir yolu olarak kullanmak isteyenler için çok faydalı olacaktır.

Uygulama

Öncelikle C_TimesAndTrade sınıfına birkaç yeni değişken eklememiz gerekiyor. Bu değişkenler aşağıdaki kodda gösterilmektedir:

#include <NanoEA-SIMD\Auxiliar\C_FnSubWin.mqh>
#include <NanoEA-SIMD\Auxiliar\C_Canvas.mqh>
//+------------------------------------------------------------------+
class C_TimesAndTrade : private C_FnSubWin
{
//+------------------------------------------------------------------+
#define def_SizeBuff 
2048 
#define macro_Limits(A) (A & 0xFF)
#define def_MaxInfos 257
//+------------------------------------------------------------------+
        private :
                string          m_szCustomSymbol,
                                m_szObjName;
                char            m_ConnectionStatus;
                datetime        m_LastTime;
                ulong           m_MemTickTime;
                int             m_CountStrings;
                struct st0
                {
                        string  szTime;
                        int     flag;
                }m_InfoTrades[def_MaxInfos];
                struct st1
                {
                        C_Canvas Canvas;
                        int      WidthRegion,
                                 PosXRegion,
                                 MaxY;
                        string   szNameCanvas;
                }m_InfoCanvas;

Vurgulanan alanlar kaynak koda eklenen kısımlardır. Görüldüğü üzere, C_Canvas sınıfını kullanmamız gerekiyor, ancak şu anda o ihtiyacımız olan tüm öğelere sahip değildir. Bu amaçla, ona dört fonksiyon ekleyeceğiz. Bu fonksiyonlar aşağıda gösterilmektedir:

// ... C_Canvas class code

inline void FontSet(const string name, const int size, const uint flags = 0, const uint angle = 0)
{
        if(!TextSetFont(name, size, flags, angle)) return;
        TextGetSize("M", m_TextInfos.width, m_TextInfos.height);
}
//+------------------------------------------------------------------+
inline void TextOutFast(int x, int y, string text, const uint clr, uint alignment = 0)
{
        TextOut(text, x, y, alignment, m_Pixel, m_width, m_height, clr, COLOR_FORMAT_ARGB_NORMALIZE);
}
//+------------------------------------------------------------------+
inline int TextWidth(void) const { return m_TextInfos.width; }
//+------------------------------------------------------------------+
inline int TextHeight(void) const { return m_TextInfos.height; }
//+------------------------------------------------------------------+

// ... The rest of the code ...

Bu satırların yaptığı iş metin oluşturmaktır. Çok basitlerdir, süslü ya da karmaşık değillerdir.

C_TimesAndTrade sınıfındaki bir sonraki dikkate değer fonksiyon şudur:

void PrintTimeTrade(void)
{
        int ui1;
        
        m_InfoCanvas.Canvas.Erase(clrBlack, 220);
        for (int c0 = 0, c1 = m_CountStrings - 1, y = 2; (c0 <= 255) && (y < m_InfoCanvas.MaxY); c0++, c1--, y += m_InfoCanvas.Canvas.TextHeight())
        if (m_InfoTrades[macro_Limits(c1)].szTime == NULL) break; else
        {
                ui1 = m_InfoTrades[macro_Limits(c1)].flag;
                m_InfoCanvas.Canvas.TextOutFast(2, y, m_InfoTrades[macro_Limits(c1)].szTime, macroColorRGBA((ui1 == 0 ? clrLightSkyBlue : (ui1 > 0 ? clrForestGreen : clrFireBrick)), 220));
        }
        m_InfoCanvas.Canvas.Update();
}

Bu fonksiyon, kendisi için ayrılmış özel alanda değerleri görüntüleyecektir. Ayrıca, başlatma prosedürü de aşağıda vurgulanan küçük değişikliklere uğramıştır:

void Init(const int iScale = 2)
{
        if (!ExistSubWin())
        {
                m_InfoCanvas.Canvas.FontSet("Lucida Console", 13);
                m_InfoCanvas.WidthRegion = (18 * m_InfoCanvas.Canvas.TextWidth()) + 4;
                CreateCustomSymbol();
                CreateChart();
                m_InfoCanvas.Canvas.Create(m_InfoCanvas.szNameCanvas, m_InfoCanvas.PosXRegion, 0, m_InfoCanvas.WidthRegion, TerminalInfoInteger(TERMINAL_SCREEN_HEIGHT), GetIdSubWinEA());
                Resize();
                m_ConnectionStatus = 0;
        }
        ObjectSetInteger(Terminal.Get_ID(), m_szObjName, OBJPROP_CHART_SCALE, (iScale > 5 ? 5 : (iScale < 0 ? 0 : iScale)));
}

Zaman ve ticaret sistemimizin boyutunda değişikliğe olanak sağlayan fonksiyonda da bazı değişiklikler yapılması gerekmektedir:

void Resize(void)
{
        static int MaxX = 0;
        int x = (int) ChartGetInteger(Terminal.Get_ID(), CHART_WIDTH_IN_PIXELS, GetIdSubWinEA());
        
        m_InfoCanvas.MaxY = (int) ChartGetInteger(Terminal.Get_ID(), CHART_HEIGHT_IN_PIXELS, GetIdSubWinEA());
        ObjectSetInteger(Terminal.Get_ID(), m_szObjName, OBJPROP_YSIZE, m_InfoCanvas.MaxY);
        if (MaxX != x)
        {
                MaxX = x;
                x -= m_InfoCanvas.WidthRegion;
                ObjectSetInteger(Terminal.Get_ID(), m_szObjName, OBJPROP_XSIZE, x);
                ObjectSetInteger(Terminal.Get_ID(), m_InfoCanvas.szNameCanvas, OBJPROP_XDISTANCE, x);
        }
        PrintTimeTrade();
}

Tüm bunlarla, sistem neredeyse hazırdır, ancak hala sistemin kalbinde yer alan fonksiyona ihtiyacı vardır. Onun üzerinde de aynı zamanda değişiklikler yapılmıştır:

inline void Update(void)
{
        MqlTick Tick[];
        MqlRates Rates[def_SizeBuff];
        int i0, p1, p2 = 0;
        int iflag;
        long lg1;
        static int nSwap = 0;
        static long lTime = 0;

        if (m_ConnectionStatus < 3) return;
        if ((i0 = CopyTicks(Terminal.GetFullSymbol(), Tick, COPY_TICKS_ALL, m_MemTickTime, def_SizeBuff)) > 0)
        {
                for (p1 = 0, p2 = 0; (p1 < i0) && (Tick[p1].time_msc == m_MemTickTime); p1++);
                for (int c0 = p1, c1 = 0; c0 < i0; c0++)
                {
                        lg1 = Tick[c0].time_msc - lTime;
                        nSwap++;
                        if (Tick[c0].volume == 0) continue;
                        iflag = 0;
                        iflag += ((Tick[c0].flags & TICK_FLAG_BUY) == TICK_FLAG_BUY ? 1 : 0);
                        iflag -= ((Tick[c0].flags & TICK_FLAG_SELL) == TICK_FLAG_SELL ? 1 : 0);
                        if (iflag == 0) continue;
                        Rates[c1].high = Tick[c0].ask;
                        Rates[c1].low = Tick[c0].bid;
                        Rates[c1].open = Tick[c0].last;
                        Rates[c1].close = Tick[c0].last + ((Tick[c0].volume > 200 ? 200 : Tick[c0].volume) * (Terminal.GetTypeSymbol() == C_Terminal::WDO ? 0.02 : 1.0) * iflag);
                        Rates[c1].time = m_LastTime;
                        m_InfoTrades[macro_Limits(m_CountStrings)].szTime = StringFormat("%02.d.%03d ~ %02.d <>%04.d", ((lg1 - (lg1 % 1000)) / 1000) % 60 , lg1 % 1000, nSwap, Tick[c0].volume);
                        m_InfoTrades[macro_Limits(m_CountStrings)].flag = iflag;
                        m_CountStrings++;
                        nSwap = 0;
			lTime = Tick[c0].time_msc;
                        p2++;
                        c1++;
                        m_LastTime += 60;
                }
                CustomRatesUpdate(m_szCustomSymbol, Rates, p2);
                m_MemTickTime = Tick[i0 - 1].time_msc;
        }
        PrintTimeTrade();
}

Vurgulanan satırlar, ihtiyacımız olan verileri modellemek için fonksiyona eklenen kod parçalarıdır. Aşağıdaki kod, işlemler arasında milisaniye cinsinden ne kadar zaman geçtiğini ve fiyat değişikliğine neden olmayan kaç işlemin gerçekleştiğini kontrol eder:

lg1 = Tick[c0].time_msc - lTime;
nSwap++;

Kontrol edilen bu değerlerin büyük olması, işlem hacminin azaldığı anlamına gelir. Bu özellik sayesinde bu detayı diğer kişilerden daha önce fark edebileceksiniz.

Aşağıdaki kod parçası ise sunulan değerleri modelleyecektir:

m_InfoTrades[macro_Limits(m_CountStrings)].szTime = StringFormat("%02.d.%03d ~ %02.d <>%04.d", ((lg1 - (lg1 % 1000)) / 1000) % 60 , lg1 % 1000, nSwap, Tick[c0].volume);
m_InfoTrades[macro_Limits(m_CountStrings)].flag = iflag;
m_CountStrings++;
nSwap = 0;                                      
lTime = Tick[c0].time_msc;

Sınırlı kullanımı nedeniyle m_CountStrings sayacını test etmeyeceğimizi lütfen unutmayın. Yeni bilgiler geldikçe basitçe değerlerini artıracağız. Bu bazen kullanılabilecek bir hiledir. Ticaret sistemi gerçek zamanlı olarak kullanılmak üzere tasarlıdır, dolayısıyla bu konuda bu numara da süreç açısından verimlilik sağlamaktadır. Her zaman sistemi mümkün olduğunca optimize etmeye çalışmalıyız, az olsa dahi - çünkü bu optimizasyonlar sonuca bakıldığında büyük bir fark yaratacaktır.

Şimdi Uzman Danışmanı derleyelim. Zaman ve ticaret sistemimiz aşağıdakine benzer bir görüntü bize sunacaktır:

Zaman ve ticaret sistemimizin grafiğini izlediğimizde, bazı mikro yapıların ortaya çıkmaya başladığını görüyoruz. Bu mikro yapılar üzerinde şahsen incelemeler yaptım, ancak var olmaları gerçeğinden öte onlardan herhangi bir avantaj elde edemedim. Ama ben o kadar deneyimli bir yatırımcı değilim, bu yüzden kim bilir, belki daha deneyimli bir kişi onlardan faydalanabilir.

Bu gösterge o kadar güçlü ve bilgilendirici ki, göstergenin değerleriyle varlığın gerçek verileri arasında karşılaştırma sunacak bir video hazırlamaya karar verdim. Sistemin pek çok bilgiyi filtrelediğini ve böylece verilerin çok daha hızlı okunmasını ve yorumlanmasını sağladığını size göstermek istedim. Umarım bu harika göstergeden keyif alır ve en iyi şekilde yararlanırsınız.

Sonuç

Burada sunduğum sistem, MetaTrader 5 platformunun kendisinde bulunan grafik sisteminin basit bir modifikasyonudur. Değiştirilen şey veri modelleme yöntemidir. Zaman ve ticaret sistemi sayesinde, kapanan işlemlerin, platformdaki mevcut en düşük zaman dilimi olan 1 dakikanın da içerisinde nasıl mikro yapılar oluşturarak fiyatın yönünü etkilediğini görmek gerçekten ilgi çekicidir. Pek çok kişi, sanki bu, yüksek düzeyde piyasa bilgisine sahip oldukları anlamına geliyormuş gibi, 1 dakikalık zaman diliminde işlem yaptıklarını söylemekten hoşlanır. Ancak daha yakından bakılıp ticaret süreçleri incelendiğinde, 1 dakikanın da içerisinde pek çok şeyin gerçekleştiği anlaşılır. Dolayısıyla, bu kısa bir süre gibi görünse de, potansiyel olarak kârlı birçok işlemin kaçırılması mümkün olabilir. Zaman ve ticaret sisteminin milisaniyeler cinsinden sağladığı grafik ve metin bilgileri, kuşkusuz ticarette yeni bir perspektif sağlayacaktır. Bir sonraki makalede görüşmek üzere.