Grid cBot¶

Stratejiye genel bakış ¶

Grid cBot, bir sembol için birden fazla alış veya satış emrinin düzenli fiyat aralıklarında veya "adımlarda" yerleştirildiği, bir pozisyon "ızgarası" oluşturan bir ızgara işlem stratejisi uygular. Sembol fiyatı değiştikçe, dalgalanmalardan faydalanmak için sürekli olarak yeni pozisyonlar açılır.

Grid cBot, pozisyonları açmak, kârları hesaplamak ve işlem operasyonlarını yönetmek için basit aritmetik ve mantıksal kontrollerin bir kombinasyonunu kullanır. En çok aralık bazlı veya yatay piyasalarda etkilidir. Ayrıca düşük volatilite koşullarında ve bilinen direnç ve destek seviyelerine sahip piyasalarda iyi performans gösterir.

cBot oluşturma ¶

C# veya Python kullanarak cBot oluşturmayı adım adım kılavuzlarımızda öğrenin.

Grid cBot kodu, herkese açık C# ve Python depolarımızda mevcuttur. Aynı kod, cTrader Windows veya Mac'teki algoritma oluşturma sihirbazında bir şablon olarak sağlanır veya aşağıdaki kod parçasını kopyalayıp kullanabilirsiniz:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class Grid : Robot
    {
        [Parameter("Volume (lots)", DefaultValue = 0.01, MinValue = 0.01, Step = 0.01)]
        public double VolumeInLots { get; set; }

        [Parameter("Trade Side")]
        public TradeType TradeType { get; set; }

        [Parameter("Step (pips)", DefaultValue = 5, MinValue = 0.1, Step = 0.1)]
        public double StepPips { get; set; }

        [Parameter("Target Profit", DefaultValue = 20)]
        public double TargetProfit { get; set; }

        private bool enoughMoney = true;

        protected override void OnStart()
        {
            if (GridPositions.Length == 0)
                OpenPosition();
        }

        protected override void OnTick()
        {
            if (GridPositions.Sum(p => p.NetProfit) >= TargetProfit)
            {
                Print("Target profit is reached. Closing all grid positions");
                CloseGridPositions();
                Print("All grid positions are closed. Stopping cBot");
                Stop();
            }
            if (GridPositions.Length > 0 && enoughMoney)
            {
                var lastGridPosition = GridPositions.OrderBy(p => p.Pips).Last();
                var distance = CalculateDistanceInPips(lastGridPosition);

                if (distance >= StepPips)
                    OpenPosition();
            }
        }

        private Position[] GridPositions
        {
            get
            {
                return Positions
                    .Where(p => p.SymbolName == SymbolName && p.TradeType == TradeType)
                    .ToArray();
            }
        }

        private double CalculateDistanceInPips(Position position)
        {
            if (position.TradeType == TradeType.Buy)
                return (position.EntryPrice - Symbol.Ask) / Symbol.PipSize;
            else
                return (Symbol.Bid - position.EntryPrice) / Symbol.PipSize;
        }

        private void OpenPosition()
        {
            var result = ExecuteMarketOrder(TradeType, SymbolName, Symbol.QuantityToVolumeInUnits(VolumeInLots), "Grid");
            if (result.Error == ErrorCode.NoMoney)
            {
                enoughMoney = false;
                Print("Not enough money to open additional positions");
            }
        }

        private void CloseGridPositions()
        {
            while (GridPositions.Length > 0)
            {
                foreach (var position in GridPositions)
                {
                    ClosePosition(position);
                }
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

class GridSample():
    def on_start(self):
        self.volumeInUnits = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
        self.enoughMoney = True
        if len(self.get_grid_positions()) == 0:
            self.open_position()

    def on_tick(self):
        grid_positions = self.get_grid_positions()
        net_profit_sum = sum([p.NetProfit for p in grid_positions])
        if net_profit_sum >= api.TargetProfit:
            api.Print("Target profit is reached. Closing all grid positions")
            self.close_grid_positions()
            api.Print("All grid positions are closed. Stopping cBot")
            api.Stop()

        if len(grid_positions) > 0 and self.enoughMoney == True:
            position_with_highest_pips = sorted(grid_positions, key=lambda pos: pos.Pips, reverse=True)[0]
            distance = self.get_distance_in_pips(position_with_highest_pips)          
            if distance >= api.StepPips:
                self.open_position()

    def get_grid_positions(self):
        return [pos for pos in api.Positions if pos.SymbolName == api.SymbolName and pos.TradeType == api.TradeType]

    def open_position(self):
        result = api.ExecuteMarketOrder(api.TradeType, api.SymbolName, self.volumeInUnits, "Grid")
        if result.Error == ErrorCode.NoMoney:
            self.enoughMoney = False
            api.Print("Not enough money to open additional positions")

    def close_grid_positions(self):
        for position in self.get_grid_positions():
            position.Close()

        if len(self.get_grid_positions()) > 0:
            self.close_grid_positions()

    def get_distance_in_pips(self, position):
        return (position.EntryPrice - api.Symbol.Ask if position.TradeType == TradeType.Buy else api.Symbol.Bid - position.EntryPrice) / api.Symbol.PipSize

Indicator entegrasyonu ¶

Grid cBot, ızgara stratejisini tanımlamak için herhangi bir göstergeye dayanmaz; bir sembol fiyatının yükselip düşeceğini tahmin etmeye çalışmaz. Bunun yerine, herhangi bir yöndeki fiyat hareketlerinden kârlı işlemler hedefler.

cBot, şu basit kurala göre işlemler gerçekleştirir: Sembol fiyatı belirli bir pip sayısının (StepPips parametresiyle tanımlanır) ötesine geçerse, cBot yeni bir pozisyon açar.

Hesaplama ve mantık ¶

İlk işlem gerçekleştirme ¶

cBot başladığında, ızgarada açık pozisyon olup olmadığını kontrol eder. Açık pozisyon yoksa, cBot OpenPosition() yöntemi aracılığıyla ilk pozisyonu hemen açar. Bu ilk adım, ızgaranın belirtilen işlem tarafına (TradeType) dayalı bir başlangıç işlemiyle başlamasını sağlar.

Kâr izleme ¶

Her tikte (örneğin, her fiyat güncellemesinde), cBot tüm açık ızgara pozisyonlarının kümülatif net kârının belirtilen hedef kâra (TargetProfit) ulaşıp ulaşmadığını veya aşıp aşmadığını kontrol eder. Hedef kâra ulaşıldıysa, tüm açık pozisyonlar kapatılır ve cBot çalışmayı durdurur.

Hedef kâr, griddeki her pozisyondan elde edilen net kârın toplamıdır.

\(n\) – griddeki açık pozisyon sayısı

\(\text{NetProfit}(p_i)\) – \(i\) pozisyonunun net kârı

Pozisyon açma ¶

Hedef kâra ulaşılmamışsa ve açık pozisyonlar varsa, cBot son açılan grid pozisyonu ile güncel piyasa fiyatı arasındaki mesafeyi (pip cinsinden) hesaplar.

Alış pozisyonları için:

Satış pozisyonları için:

\(D_b\) – giriş fiyatı ile güncel alış fiyatı arasındaki pip cinsinden mesafe.

\(D_s\) – güncel satış fiyatı ile giriş fiyatı arasındaki pip cinsinden mesafe.

\(P_e\) – sembol için son alış pozisyonunun açıldığı fiyat.

\(P_a\) – sembol için güncel alış fiyatı.

\(P_b\) – sembol için güncel satış fiyatı.

\(S\) – sembol için bir pipin değeri.

Hesaplanan mesafe tanımlanan adım boyutundan (StepPips) büyük veya eşitse, OpenPosition() yöntemi kullanılarak yeni bir pozisyon açılır.

cBot, her yeni pozisyon açmadan önce işlem için yeterli fon olup olmadığını kontrol eder ve onaylar. Fonlar yetersizse, cBot yeni pozisyon açma girişimlerini durdurur ve "Ek pozisyon açmak için yeterli para yok" mesajını kaydeder.

Pozisyon kapatma ¶

TargetProfit'e ulaşıldığında, cBot "Hedef kâra ulaşıldı. Tüm grid pozisyonları kapatılıyor" mesajını kaydeder.

CloseGridPositions() yöntemi daha sonra griddeki tüm açık pozisyonları döngüye alarak kapatır ve ardından cBot "Tüm grid pozisyonları kapatıldı. cBot durduruluyor" mesajını kaydeder. cBot daha sonra durdurulur.

Parametreler ¶

Uygulama ¶

Bant aralığında işlem gören veya yatay piyasalar ¶

Grid cBot, fiyatın destek ve direnç seviyeleri arasında salındığı bant aralığında işlem gören piyasalarda en etkilidir. Bu tür piyasalarda, fiyatlar tanımlanmış bir aralıkta sık sık yukarı ve aşağı hareket ettikçe, cBot düzenli olarak pozisyon açar ve dalgalanmalardan faydalanır.

Düşük volatiliteye sahip piyasalar ¶

Düşük volatiliteye sahip piyasalarda, fiyat hareketleri yavaş ve daha az belirgin olma eğilimindedir. Fiyat kademeli olarak hareket ettikçe, Grid cBot büyük, hızlı piyasa hareketleri riskiyle karşılaşmadan birden fazla pozisyon açmak için yeterli zamana sahip olur.

Bilinen seviyelere sahip piyasalar ¶

Grid cBot, güçlü, iyi tanımlanmış destek ve direnç seviyelerine sahip piyasalarda iyi performans gösterebilir. Bu seviyeler fiyat bariyerleri görevi görür ve piyasanın sık sık geri sıçramasına neden olarak cBot'un faydalanabileceği bir aralık oluşturur.

Yönsüz piyasalar ¶

Bazı döviz çiftleri sık fiyat dalgalanmalarıyla yönsüz hareket sergiler, ancak fiyatları güçlü bir uzun vadeli trend göstermez. Grid cBot, bu tür piyasalarda iyi çalışır çünkü uzun vadeli bir trende yakalanma riski olmadan sık dalgalanmaları yakalayabilir.

Özet ¶

Grid cBot, hem yükseliş hem de düşüş piyasalarında geri çekilmeler veya düzeltmeler olacağı varsayımıyla çalışır. Yükseliş piyasalarında düşükten alır ve yüksekten satar, düşüş piyasalarında yüksekten satar ve düşükten alır; cBot, piyasa geri çekilmelerden sonra ana trendine döndüğünde kâr elde eder.

cBot göstergeler kullanmadığı için piyasanın trendde mi yoksa aralıkta mı olduğunu değerlendiremez. Piyasa duyarlılığını veya trend gücünü göz ardı ederek sadece fiyat hareketine dayalı pozisyonlar açar.

Göstergelerin olmaması, işlem sürecini tamamen mekanik hale getirir; cBot, düzenli aralıklarla pozisyon açmak için yalnızca önceden tanımlanmış kurallara güvenir. Bu yaklaşım aralıkta işlem gören piyasalarda kârlı olabilirken, trendde olan, yüksek volatiliteye sahip veya hızla değişen piyasalarda zarar etme eğilimindedir.

cBot'u kişisel stratejilerini uygulamak üzere yapılandırmanın yanı sıra, trader'lar piyasa koşullarına göre işlemleri filtrelemek için göstergeler kullanmayı düşünebilirler:

• Moving Averages (MA) piyasa trendini belirlemeye yardımcı olabilir, cBot'un yalnızca trend yönünde işlem yapmasını sağlar.
• Relative Strength Index (RSI) aşırı alım veya aşırı satım koşullarını işaret edebilir, piyasa tek bir yöne doğru gerildiğinde cBot'un yeni pozisyonlar açmaktan kaçınmasına yardımcı olur.
• Bollinger Bands fiyat volatilitesi hakkında bilgi sağlayabilir, cBot'un yüksek volatilite dönemlerinde grid aralığını ayarlamasına veya işlem yapmayı ertelemesine olanak tanır.