Martingale cBot¶

Przegląd strategii ¶

Martingale cBot to robot handlowy, który implementuje strategię Martingale, klasyczny system obstawiania zaadaptowany na rynki finansowe. Odkryta przez francuskich matematyków w XVIII wieku strategia Martingale szybko stała się popularna wśród graczy w kasynach.

Tworzenie cBota ¶

Dowiedz się, jak tworzyć cBoty, używając C# lub Pythona, w naszych szczegółowych przewodnikach.

Kod Martingale cBot jest dostępny w naszych publicznych repozytoriach C# i Python. Ten sam kod jest dostępny jako szablon w kreatorze tworzenia algorytmów w aplikacji cTrader Windows lub Mac, lub możesz po prostu skopiować i użyć poniższego fragmentu kodu:

 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

Integracja wskaźnika ¶

Martingale cBot nie używa żadnego modelu predykcyjnego ani wskaźnika technicznego do prognozowania kierunku rynku. Zamiast tego opiera się na losowej szansie przy podejmowaniu decyzji o kupnie i sprzedaży, co skutkuje nieprzewidywalnymi wynikami (zysk lub strata) dla każdej transakcji.

Logika ¶

Losowy kierunek transakcji ¶

• cBot losowo wybiera, czy złożyć zlecenie kupna, czy sprzedaży za pomocą metody GetRandomTradeType().

• Metoda ExecuteOrder() składa zlecenie rynkowe z wolumenem, stop loss i take profit zdefiniowanymi w parametrach.

Mechanizm Martingale ¶

• cBot wykrywa zamknięcie pozycji za pomocą procedury obsługi zdarzeń OnPositionsClosed().
• Jeśli zamknięta pozycja przynosi zysk, cBot resetuje się i otwiera nową transakcję z początkowym rozmiarem lota i losowym kierunkiem transakcji.
• Jeśli zamknięta pozycja przynosi stratę, cBot podwaja wolumen następnej transakcji, ale zachowuje ten sam kierunek transakcji (kupno lub sprzedaż) co poprzednia transakcja.

Zarządzanie ryzykiem ¶

• cBot opiera się na strategii Martingale polegającej na podwajaniu wielkości pozycji po każdej przegranej transakcji, aby odzyskać straty i osiągnąć zysk po udanej transakcji.
• Domyślne wartości stop-loss i take-profit mają na celu zrównoważenie ryzyka i zysku w każdej transakcji.

Wykonanie i zakończenie ¶

Jeśli cBot napotka błąd z powodu niewystarczających środków (NoMoney), cBot przestaje próbować zawierać transakcje.

Parametry ¶

Aplikacja ¶

Rynki ograniczone zakresem lub boczne ¶

Martingale cBot sprawdza się doskonale na rynkach poruszających się bocznie, gdzie nie ma dominującego trendu wzrostowego ani spadkowego. Na rynkach w konsolidacji ceny wahają się między poziomami wsparcia i oporu, co sprawia, że cBot prawdopodobnie szybko odzyska straty po stratnych transakcjach.

Rynki o niskiej zmienności ¶

cBot może być używany w warunkach niskiej zmienności, gdzie ruchy cen są mniej skłonne do wyzwalania kolejnych stop lossów, zapobiegając szybkiemu wzrostowi pozycji. Takie warunki pozwalają strategii Martingale działać dobrze dzięki stopniowym odwróceniom cen.

Aktywa powracające do średniej ¶

Symbole, które często powracają do średniego poziomu ceny, są dobrze dopasowane do Martingale cBot, ponieważ często doświadczają odwróceń przed utworzeniem długoterminowego trendu. W takich warunkach cBot może szybciej odzyskać straty i osiągnąć zyski, zwiększając wielkość pozycji po stratach.

Podsumowanie ¶

Martingale cBot to zautomatyzowany algorytm handlowy, który implementuje popularną strategię Martingale. Ten cBot opiera swoje decyzje kupna i sprzedaży wyłącznie na przypadku, rezygnując z modeli predykcyjnych lub wskaźników technicznych, co prowadzi do niepewnych wyników każdej transakcji.

Działając przy założeniu, że rynki ostatecznie będą sprzyjać traderowi, Martingale cBot podwaja wielkość transakcji po stratach, aby odzyskać je jedną zyskowną transakcją. Ten cBot może być skuteczny na określonych rynkach, szczególnie gdy użytkownicy są dobrze poinformowani o ryzykach i mają wystarczające zasoby, aby wytrzymać przedłużające się spadki.