Martingale cBot¶

Visão geral da estratégia ¶

O Martingale cBot é um robô de negociação que implementa a estratégia Martingale, um sistema de apostas clássico adaptado para os mercados financeiros. Descoberta por matemáticos franceses no século XVIII, a estratégia Martingale rapidamente se tornou popular entre apostadores em casinos.

Criação de cBot ¶

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

O código do Martingale 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

using cAlgo.API;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class SampleMartingalecBot : Robot
    {
        [Parameter("Initial Quantity (Lots)", Group = "Volume", DefaultValue = 1, MinValue = 0.01, Step = 0.01)]
        public double InitialQuantity { get; set; }

        [Parameter("Stop Loss", Group = "Protection", DefaultValue = 40)]
        public int StopLoss { get; set; }

        [Parameter("Take Profit", Group = "Protection", DefaultValue = 40)]
        public int TakeProfit { get; set; }


        private Random random = new Random();

        protected override void OnStart()
        {
            Positions.Closed += OnPositionsClosed;

            ExecuteOrder(InitialQuantity, GetRandomTradeType());
        }

        private void ExecuteOrder(double quantity, TradeType tradeType)
        {
            var volumeInUnits = Symbol.QuantityToVolumeInUnits(quantity);
            var result = ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, "Martingale", StopLoss, TakeProfit);

            if (result.Error == ErrorCode.NoMoney)
                Stop();
        }

        private void OnPositionsClosed(PositionClosedEventArgs args)
        {
            Print("Closed");
            var position = args.Position;

            if (position.Label != "Martingale" || position.SymbolName != SymbolName)
                return;

            if (position.GrossProfit > 0)
            {
                ExecuteOrder(InitialQuantity, GetRandomTradeType());
            }
            else
            {
                ExecuteOrder(position.Quantity * 2, position.TradeType);
            }
        }

        private TradeType GetRandomTradeType()
        {
            return random.Next(2) == 0 ? TradeType.Buy : TradeType.Sell;
        }
    }
}

 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

import clr

clr.AddReference("cAlgo.API")

from cAlgo.API import *

from robot_wrapper import *

import random

class SampleMartingalecBot():
    def on_start(self):
        api.Positions.Closed += self.on_position_closed
        self.execute_order(api.InitialQuantity, self.get_random_trade_type())

    def execute_order(self, quantity, tradeType):
        volumeInUnits = api.Symbol.QuantityToVolumeInUnits(quantity)
        result = api.ExecuteMarketOrder(tradeType, api.SymbolName, volumeInUnits, "Martingale",  api.StopLoss,  api.TakeProfit)
        if result.Error == ErrorCode.NoMoney:
            api.Stop()

    def on_position_closed(self, args):
        api.Print("Closed")

        position = args.Position
        if position.Label != "Martingale" or position.SymbolName != api.SymbolName:
            return
        if position.GrossProfit > 0:
            self.execute_order(api.InitialQuantity, self.get_random_trade_type())
        else:
            self.execute_order(position.Quantity * 2, position.TradeType)

    def get_random_trade_type(self):
        return TradeType.Buy if random.randint(0, 1) == 0 else TradeType.Sell

Integração de indicadores ¶

O Martingale cBot não utiliza qualquer modelo preditivo ou indicador técnico para prever a direção do mercado. Em vez disso, baseia-se no acaso para as decisões de compra e venda, resultando em resultados imprevisíveis (lucro ou perda) para cada negociação.

Lógica ¶

Direção de negociação aleatória ¶

• O cBot seleciona aleatoriamente se deve colocar uma ordem de compra ou venda através do método GetRandomTradeType().

• O método ExecuteOrder() coloca uma ordem de mercado com a quantidade, stop loss e take profit definidos nos parâmetros.

Mecanismo Martingale ¶

• O cBot deteta quando uma posição é fechada através do manipulador de eventos OnPositionsClosed().
• Se a posição fechada resultar em lucro, o cBot reinicia-se e abre uma nova negociação com o tamanho inicial do lote e uma direção aleatória de negociação.
• Se a posição fechada resultar em perda, o cBot duplica a quantidade da próxima negociação mas mantém a mesma direção de negociação (compra ou venda) da negociação anterior.

Gestão de risco ¶

• O cBot baseia-se na estratégia Martingale de duplicar o tamanho da posição após cada negociação perdedora para recuperar perdas e obter lucro quando ocorre uma negociação bem-sucedida.
• Os valores predefinidos de stop loss e take profit visam equilibrar o risco e a recompensa em cada negociação.

Execução e encerramento ¶

Se o cBot encontrar um erro devido a fundos insuficientes (NoMoney), o cBot para de tentar fazer negociações.

Parâmetros ¶

Aplicação ¶

Mercados limitados ou laterais ¶

O Martingale cBot destaca-se em mercados que se movem lateralmente, onde não existe uma tendência dominante de subida ou descida. Em mercados limitados, os preços flutuam entre níveis de suporte e resistência, tornando provável que o cBot recupere rapidamente as perdas após negociações perdedoras.

Mercados de baixa volatilidade ¶

O cBot pode ser usado em condições de baixa volatilidade onde os movimentos de preço têm menos probabilidade de acionar stop losses consecutivos, evitando o crescimento rápido de posições. Tais condições permitem que a estratégia Martingale funcione bem através de reversões graduais de preço.

Ativos de reversão à média ¶

Os símbolos que frequentemente revertem para um nível médio de preço são adequados para o Martingale cBot, pois frequentemente experimentam reversões antes de formar uma tendência de longo prazo. Nestas condições, o cBot pode recuperar mais rapidamente e obter ganhos aumentando o tamanho das suas posições após perdas.

Summary ¶

O Martingale cBot é um algoritmo de negociação automatizado que implementa a popular estratégia Martingale. Este cBot baseia as suas decisões de compra e venda inteiramente no acaso, prescindindo de modelos preditivos ou indicadores técnicos, o que leva a resultados incertos para cada negociação.

Operando sob a premissa de que os mercados eventualmente favorecerão o trader, o Martingale cBot duplica o tamanho da negociação após perdas para recuperá-las com uma única negociação lucrativa. Este cBot pode ser eficaz em determinados mercados, especialmente quando os utilizadores estão bem informados sobre os riscos e têm recursos suficientes para suportar drawdowns prolongados.