Martingale cBot¶

Strategieübersicht ¶

Martingale cBot ist ein Handelsroboter, der die Martingale-Strategie implementiert, ein klassisches Wettsystem, das für Finanzmärkte angepasst wurde. Die von französischen Mathematikern im 18. Jahrhundert entdeckte Martingale-Strategie wurde schnell bei Wettern in Casinos beliebt.

cBot-Erstellung ¶

Erfahren Sie in unseren Schritt-für-Schritt-Anleitungen, wie Sie cBots erstellen, entweder mit C# oder Python.

Der Martingale cBot-Code ist in unseren öffentlichen C#- und Python-Repositories verfügbar. Derselbe Code wird als Vorlage im Erstellungsassistenten für Algorithmen in cTrader Windows oder Mac bereitgestellt, oder Sie können einfach den folgenden Codeausschnitt kopieren und verwenden:

 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

Indikatorintegration ¶

Martingale cBot verwendet kein Vorhersagemodell oder keinen technischen Indikator, um die Richtung des Marktes vorherzusagen. Stattdessen verlässt er sich auf eine zufällige Chance für Kauf- und Verkaufsentscheidungen, was zu unvorhersehbaren Ergebnissen (Gewinn oder Verlust) für jede Transaktion führt.

Logik ¶

Zufällige Handelsrichtung ¶

• Der cBot wählt zufällig aus, ob er eine Kauf- oder Verkaufsorder über die Methode GetRandomTradeType() platziert.

• Die Methode ExecuteOrder() platziert eine Market-Order mit der Menge, dem Stop-Loss und dem Take-Profit, die in den Parametern definiert sind.

Martingale-Mechanismus ¶

• Der cBot erkennt, wann eine Position geschlossen wird, über den Event-Handler OnPositionsClosed().
• Wenn die geschlossene Position zu einem Gewinn führt, setzt sich der cBot zurück und eröffnet eine neue Transaktion mit der anfänglichen Lotgröße und einer zufälligen Handelsrichtung.
• Wenn die geschlossene Position zu einem Verlust führt, verdoppelt der cBot die Menge der nächsten Transaktion, behält aber dieselbe Handelsrichtung (Kauf oder Verkauf) wie bei der vorherigen Transaktion bei.

Risikomanagement ¶

• Der cBot verlässt sich auf die Martingale-Strategie, die Positionsgröße nach jeder verlorenen Transaktion zu verdoppeln, um Verluste auszugleichen und einen Gewinn zu erzielen, sobald eine erfolgreiche Transaktion stattfindet.
• Die Standard-Stop-Loss- und Take-Profit-Werte zielen darauf ab, das Risiko und die Belohnung bei jeder Transaktion auszugleichen.

Ausführung und Beendigung ¶

Wenn der cBot aufgrund unzureichender Mittel (NoMoney) auf einen Fehler stößt, hört der cBot auf, Transaktionen durchzuführen.

Parameter ¶

Anwendung ¶

Bereichsgebundene oder seitwärts gerichtete Märkte ¶

Der Martingale cBot zeichnet sich in Märkten aus, die sich seitwärts bewegen, wo es keinen dominanten Aufwärts- oder Abwärtstrend gibt. In Seitwärtsmärkten schwanken die Kurse zwischen Unterstützungs- und Widerstandsniveaus, wodurch es wahrscheinlich ist, dass der cBot Verluste nach verlustreichen Transaktionen schnell wieder ausgleicht.

Märkte mit geringer Volatilität ¶

Der cBot kann unter Bedingungen geringer Volatilität eingesetzt werden, bei denen Kursbewegungen weniger wahrscheinlich aufeinanderfolgende Stop-Losses auslösen und so ein schnelles Positionswachstum verhindern. Solche Bedingungen ermöglichen es der Martingale-Strategie, durch allmähliche Kursumkehrungen gut zu funktionieren.

Mean-Reverting-Assets ¶

Symbole, die häufig zu einem durchschnittlichen Kursniveau zurückkehren, eignen sich gut für den Martingale cBot, da sie oft Umkehrungen erfahren, bevor sich ein langfristiger Trend bildet. Unter solchen Bedingungen kann sich der cBot schneller erholen und Gewinne erzielen, indem er seine Positionsgrößen nach Verlusten erhöht.

Zusammenfassung ¶

Der Martingale cBot ist ein automatisierter Handelsalgorithmus, der die beliebte Martingale-Strategie umsetzt. Dieser cBot stützt seine Kauf- und Verkaufsentscheidungen vollständig auf Zufall und verzichtet auf Vorhersagemodelle oder technische Indikatoren, was zu ungewissen Ergebnissen für jede Transaktion führt.

Unter der Annahme, dass die Märkte letztendlich den Händler begünstigen werden, verdoppelt der Martingale cBot die Transaktionsgröße nach Verlusten, um diese mit einer einzigen profitablen Transaktion auszugleichen. Dieser cBot kann in bestimmten Märkten effektiv sein, insbesondere wenn Benutzer über die Risiken gut informiert sind und über ausreichende Ressourcen verfügen, um anhaltende Drawdowns zu überstehen.