Martingale cBot¶

Ikhtisar strategi ¶

Martingale cBot adalah robot trading yang mengimplementasikan strategi Martingale, sistem taruhan klasik yang diadaptasi untuk pasar keuangan. Ditemukan oleh matematikawan Prancis pada abad ke-18, strategi Martingale dengan cepat menjadi populer di kalangan petaruh di kasino.

Pembuatan cBot ¶

Pelajari cara membuat cBot, menggunakan C# atau Python, dalam panduan langkah demi langkah kami.

Kode Martingale cBot tersedia di repositori publik kami C# dan Python. Kode yang sama disediakan sebagai templat dalam wizard pembuatan algoritma di cTrader Windows atau Mac, atau Anda dapat menyalin dan menggunakan cuplikan di bawah ini:

 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

Integrasi indikator ¶

Martingale cBot tidak menggunakan model prediktif atau indikator teknikal untuk meramalkan arah pasar. Sebaliknya, ia mengandalkan peluang acak untuk keputusan beli dan jual, menghasilkan hasil yang tidak dapat diprediksi (laba atau rugi) untuk setiap trading.

Logika ¶

Arah trading acak ¶

• cBot secara acak memilih apakah akan menempatkan order beli atau jual melalui metode GetRandomTradeType().

• Metode ExecuteOrder() menempatkan order market dengan kuantitas, Stop Loss dan Take Profit yang ditentukan dalam parameter.

Mekanisme Martingale ¶

• cBot mendeteksi ketika posisi ditutup melalui penangan event OnPositionsClosed().
• Jika posisi yang ditutup menghasilkan laba, cBot mereset dirinya dan membuka trading baru dengan ukuran lot awal dan arah trading acak.
• Jika posisi yang ditutup menghasilkan kerugian, cBot menggandakan kuantitas trading berikutnya tetapi mempertahankan arah trading yang sama (beli atau jual) seperti trading sebelumnya.

Manajemen risiko ¶

• cBot mengandalkan strategi Martingale yaitu menggandakan ukuran posisi setelah setiap trading yang rugi untuk memulihkan kerugian dan mendapatkan laba setelah trading yang berhasil terjadi.
• Nilai Stop Loss dan Take Profit default bertujuan untuk menyeimbangkan risiko dan imbalan pada setiap trading.

Eksekusi dan penghentian ¶

Jika cBot mengalami error karena dana tidak mencukupi (NoMoney), cBot berhenti mencoba melakukan trading.

Parameter ¶

Penerapan ¶

Pasar yang bergerak sideways atau dalam rentang ¶

Martingale cBot unggul di pasar yang bergerak sideways, di mana tidak ada tren naik atau turun yang dominan. Di pasar yang bergerak dalam rentang, harga berfluktuasi antara level support dan resistance, sehingga memungkinkan cBot untuk memulihkan kerugian dengan cepat setelah mengalami perdagangan yang rugi.

Pasar dengan volatilitas rendah ¶

cBot dapat digunakan dalam kondisi volatilitas rendah di mana pergerakan harga cenderung tidak memicu Stop Loss berturut-turut, sehingga mencegah pertumbuhan posisi yang cepat. Kondisi seperti ini memungkinkan strategi Martingale bekerja dengan baik melalui pembalikan harga secara bertahap.

Aset yang kembali ke rata-rata ¶

Simbol yang sering kembali ke tingkat harga rata-rata sangat cocok untuk Martingale cBot, karena mereka sering mengalami pembalikan sebelum membentuk tren jangka panjang. Dalam kondisi seperti itu, cBot dapat pulih lebih cepat dan mendapatkan keuntungan dengan meningkatkan ukuran posisinya setelah mengalami kerugian.

Summary ¶

Martingale cBot adalah algoritma trading otomatis yang mengimplementasikan strategi Martingale yang populer. cBot ini membuat keputusan beli dan jual sepenuhnya berdasarkan keberuntungan acak, mengabaikan model prediktif atau indikator teknikal, yang mengakibatkan hasil yang tidak pasti untuk setiap trading.

Beroperasi dengan asumsi bahwa pasar pada akhirnya akan menguntungkan trader, Martingale cBot menggandakan ukuran trading setelah kerugian untuk menutupinya dengan satu trading yang menguntungkan. cBot ini mungkin efektif di pasar tertentu, terutama ketika pengguna memahami risiko dan memiliki sumber daya yang cukup untuk menahan penarikan yang berkepanjangan.