Martingale cBot¶

Aperçu de la stratégie ¶

Martingale cBot est un robot de trading qui met en œuvre la stratégie Martingale, un système de paris classique adapté aux marchés financiers. Découverte par des mathématiciens français au XVIIIe siècle, la stratégie Martingale est rapidement devenue populaire parmi les parieurs dans les casinos.

Création de cBot ¶

Découvrez comment créer des cBots, en utilisant C# ou Python, dans nos guides étape par étape.

Le code du Martingale cBot est disponible dans nos dépôts publics C# et Python. Le même code est fourni comme modèle dans l'assistant de création d'algorithmes dans cTrader Windows ou Mac, ou vous pouvez simplement copier et utiliser l'extrait ci-dessous :

 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

Intégration de l'indicateur ¶

Le Martingale cBot n'utilise aucun modèle prédictif ni indicateur technique pour prévoir la direction du marché. Au lieu de cela, il s'appuie sur le hasard pour les décisions d'achat et de vente, ce qui entraîne des résultats imprévisibles (profit ou perte) pour chaque trade.

Logique ¶

Direction de trade aléatoire ¶

• Le cBot sélectionne aléatoirement s'il doit placer un ordre d'achat ou de vente via la méthode GetRandomTradeType().

• La méthode ExecuteOrder() place un ordre au marché avec la quantité, le stop loss et le take profit définis dans les paramètres.

Mécanisme Martingale ¶

• Le cBot détecte lorsqu'une position est fermée via le gestionnaire d'événements OnPositionsClosed().
• Si la position fermée génère un profit, le cBot se réinitialise et ouvre un nouveau trade avec la taille de lot initiale et une direction de trade aléatoire.
• Si la position fermée génère une perte, le cBot double la quantité du trade suivant mais conserve la même direction de trade (achat ou vente) que le trade précédent.

Gestion des risques ¶

• Le cBot s'appuie sur la stratégie Martingale qui consiste à doubler la taille de la position après chaque trade perdant afin de récupérer les pertes et de réaliser un profit dès qu'un trade réussi se produit.
• Les valeurs par défaut du stop loss et du take profit visent à équilibrer le risque et le rendement sur chaque trade.

Exécution et arrêt ¶

Si le cBot rencontre une erreur due à des fonds insuffisants (NoMoney), le cBot cesse d'essayer d'effectuer des trades.

Paramètres ¶

Application ¶

Marchés limités ou latéraux ¶

Le Martingale cBot excelle dans les marchés qui évoluent latéralement, où il n'y a pas de tendance haussière ou baissière dominante. Dans les marchés en range, les prix fluctuent entre les niveaux de support et de résistance, ce qui rend probable que le cBot récupère rapidement les pertes après des trades perdants.

Marchés à faible volatilité ¶

Le cBot peut être utilisé dans des conditions de faible volatilité où les mouvements de prix sont moins susceptibles de déclencher des stop loss consécutifs, empêchant une croissance rapide de la position. De telles conditions permettent à la stratégie Martingale de bien fonctionner grâce à des inversions de prix graduelles.

Actifs à retour à la moyenne ¶

Les symboles qui reviennent fréquemment à un niveau de prix moyen sont bien adaptés au Martingale cBot, car ils connaissent souvent des inversions avant de former une tendance à long terme. Dans de telles conditions, le cBot peut récupérer plus rapidement et réaliser des gains en augmentant la taille de ses positions après des pertes.

Résumé ¶

Le Martingale cBot est un algorithme de trading automatisé qui met en œuvre la stratégie Martingale populaire. Ce cBot base ses décisions d'achat et de vente entièrement sur le hasard, renonçant aux modèles prédictifs ou aux indicateurs techniques, ce qui conduit à des résultats incertains pour chaque trade.

Partant du principe que les marchés finiront par favoriser le trader, le Martingale cBot double la taille du trade après les pertes pour les récupérer avec un seul trade rentable. Ce cBot peut être efficace dans certains marchés, en particulier lorsque les utilisateurs sont bien informés des risques et disposent de ressources suffisantes pour supporter des pertes prolongées.