Grid cBot¶

Visão geral da estratégia ¶

O Grid cBot implementa uma estratégia de negociação em grelha onde várias ordens de compra ou venda para um símbolo são colocadas em intervalos regulares de preço ou "passos", formando uma "grelha" de posições. À medida que o preço do símbolo muda, novas posições são constantemente abertas para tirar proveito das flutuações.

O Grid cBot utiliza uma combinação de verificações aritméticas e lógicas simples para abrir posições, calcular lucros e gerir as suas operações de negociação. É mais eficaz em mercados limitados por intervalos ou laterais. Também tem um bom desempenho em condições de baixa volatilidade e mercados com níveis conhecidos de resistência e suporte.

Criação de cBot ¶

Saiba como criar cBots, usando C# ou Python, nos nossos guias passo a passo.

O código do Grid cBot está disponível nos nossos repositórios públicos C# e Python. O mesmo código é fornecido como um modelo no assistente de criação de algoritmos no cTrader Windows ou Mac, ou pode simplesmente copiar e usar o snippet abaixo:

 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

Integração de indicadores ¶

O Grid cBot não depende de nenhum indicador para definir a sua estratégia de grelha; não tenta prever se o preço de um símbolo vai subir ou descer. Em vez disso, procura negociações lucrativas a partir de movimentos de preço em qualquer direção.

O cBot executa negociações com base nesta regra simples: Se o preço do símbolo se mover além de um número específico de pips (definido pelo parâmetro StepPips), o cBot abre uma nova posição.

Cálculo e lógica ¶

Execução inicial da negociação ¶

Quando o cBot inicia, verifica se existem posições abertas na grelha. Se não houver posições abertas, o cBot abre imediatamente a primeira posição através do método OpenPosition(). Este primeiro passo garante que a grelha começa com uma negociação inicial baseada no lado de negociação especificado (TradeType).

Monitorização do lucro ¶

Em cada tick (por exemplo, cada atualização de preço), o cBot verifica se o lucro líquido acumulado de todas as posições abertas na grelha atinge ou excede o lucro alvo especificado (TargetProfit). Se o lucro alvo tiver sido atingido, todas as posições abertas são fechadas e o cBot para de funcionar.

O lucro alvo é a soma do lucro líquido de cada posição na grelha.

\(n\) – número de posições abertas na grelha

\(\text{NetProfit}(p_i)\) – lucro líquido da posição \(i\)

Abertura de posições ¶

Se o lucro pretendido não tiver sido atingido e existirem posições abertas, o cBot calcula a distância (em pips) entre a última posição da grelha aberta e o preço atual de mercado.

Para posições de compra:

Para posições de venda:

\(D_b\) – distância em pips entre o preço de entrada e o preço de compra atual.

\(D_s\) – distância em pips entre o preço de venda atual e o preço de entrada.

\(P_e\) – preço ao qual foi aberta a última posição de compra para o símbolo.

\(P_a\) – preço de compra atual para o símbolo.

\(P_b\) – preço de venda atual para o símbolo.

\(S\) – valor de um pip para o símbolo.

Se a distância calculada for maior ou igual ao tamanho do passo definido (StepPips), uma nova posição é aberta usando o método OpenPosition().

Cada vez que abre uma nova posição, o cBot verifica e confirma que existem fundos suficientes para a operação. Se os fundos forem insuficientes, o cBot para de tentar abrir novas posições e regista a mensagem "Not enough money to open additional positions".

Fecho de posições ¶

Assim que o TargetProfit é atingido, o cBot regista a mensagem "Target profit is reached. Closing all grid positions".

O método CloseGridPositions() percorre então todas as posições abertas na grelha, fecha-as e depois o cBot regista a mensagem "All grid positions are closed. Stopping cBot". O cBot é então interrompido.

Parâmetros ¶

Aplicação ¶

Mercados limitados ou laterais ¶

O Grid cBot é mais eficaz em mercados limitados por intervalos onde o preço oscila entre níveis de suporte e resistência. Nesses mercados, como os preços se movem frequentemente para cima e para baixo dentro de um intervalo definido, o cBot abre posições regularmente e capitaliza nas flutuações.

Mercados de baixa volatilidade ¶

Em mercados de baixa volatilidade, os movimentos de preços tendem a ser lentos e menos pronunciados. À medida que o preço se move gradualmente, o Grid cBot tem tempo suficiente para abrir várias posições sem enfrentar o risco de movimentos de mercado grandes e rápidos.

Mercados com níveis conhecidos ¶

O Grid cBot pode ter um bom desempenho em mercados com níveis de suporte e resistência fortes e bem definidos. Esses níveis atuam como barreiras de preço e fazem com que o mercado frequentemente retorne, resultando num intervalo que o cBot pode explorar.

Mercados não direcionais ¶

Certos pares de moedas exibem movimento não direcional com frequentes flutuações de preço, mas o seu preço não mostra uma forte tendência a longo prazo. O Grid cBot funciona bem em tais mercados porque pode capturar flutuações frequentes sem o risco de ser apanhado numa tendência de longo prazo.

Resumo ¶

O Grid cBot opera com base no pressuposto de que durante mercados tanto em alta como em baixa, haverá retrocessos ou recuos. Compra baixo e vende alto em mercados em alta e vende alto e compra baixo em mercados em baixa; o cBot captura lucros quando o mercado retoma a tendência principal após os retrocessos.

Uma vez que o cBot não usa indicadores, não consegue avaliar se o mercado está em tendência ou em intervalo. Simplesmente abre posições com base apenas no movimento do preço, ignorando o sentimento do mercado ou a força da tendência.

A ausência de indicadores torna o processo de negociação puramente mecânico; o cBot depende apenas de regras predefinidas para abrir posições em intervalos regulares. Embora esta abordagem possa ser lucrativa em mercados limitados por intervalos, tende a sofrer em mercados com tendência, altamente voláteis ou em rápida mudança.

Além de configurar o cBot para aplicar as suas estratégias pessoais, os traders podem considerar introduzir indicadores para filtrar negociações com base nas condições de mercado:

• As Moving Averages (MA) podem ajudar a identificar a tendência do mercado, permitindo que o cBot negocie apenas na direção da tendência.
• O Relative Strength Index (RSI) pode sinalizar condições de sobrecompra ou sobrevenda, ajudando o cBot a evitar abrir novas posições quando o mercado está esticado numa direção.
• As Bollinger Bands podem fornecer informações sobre a volatilidade dos preços, permitindo que o cBot ajuste o espaçamento da grelha ou se abstenha de negociar durante períodos de alta volatilidade.