Strategi ini menggunakan kaedah perdagangan grid dalam teori lautan untuk meletakkan pesanan beli dan jual dalam julat harga yang telah ditetapkan. Strategi ini mempunyai pengiraan automatik julat harga grid dan pengedaran garis grid yang seragam, yang membantu menguruskan risiko dengan berkesan.
Strategi ini mula-mula mengira batas atas dan bawah grid harga berdasarkan pilihan pengguna atau tetapan lalai. Terdapat dua cara pengiraan: mendapatkan harga tertinggi dan terendah dalam tempoh backtesting, atau mengira purata bergerak dalam satu jangka masa. Kemudian garis grid diedarkan secara seragam mengikut bilangan grid yang ditetapkan oleh pengguna.
Isyarat perdagangan dihasilkan berdasarkan hubungan antara harga dan garis grid. Apabila harga berada di bawah garis grid, kedudukan panjang dibuka pada harga garis grid dengan kuantiti tetap; apabila harga berada di atas garis grid, kedudukan ditutup di garis grid di bawah. Apabila harga turun naik di dalam grid, kedudukan berubah dengan sewajarnya untuk memperoleh keuntungan.
Secara khusus, strategi ini mengekalkan array harga garis grid dan array bool yang menunjukkan sama ada pesanan diletakkan di setiap baris. Apabila harga berada di bawah garis tanpa pesanan, kedudukan panjang dibuka di baris; apabila harga berada di atas garis sementara pesanan wujud di baris di bawah, kedudukan ditutup di baris bawah. Dagangan grid dilaksanakan dengan cara ini.
Julat grid dikira secara automatik, mengelakkan kesukaran tetapan manual.
Garis grid diedarkan secara merata untuk mengelakkan overtrading kerana grid yang padat.
Kaedah perdagangan grid mengawal risiko dengan berkesan. Keuntungan boleh diperoleh selagi harga turun naik dalam grid.
Tiada andaian arah harga, sesuai untuk pasaran terhad julat.
Seting komisen dan saiz kedudukan yang boleh disesuaikan untuk instrumen dagangan yang berbeza.
Visualisasi garis grid membantu memahami keadaan perdagangan.
Risiko harga pecah. melanggar had grid atas atau bawah boleh membawa kepada kerugian yang lebih besar.
Risiko ruang grid yang berlebihan. Grid yang terlalu longgar tidak dapat memperoleh keuntungan dengan mudah sementara terlalu sempit meningkatkan kos. Keseimbangan diperlukan.
Risiko memegang jangka panjang membuat keuntungan sukar tetapi meningkatkan kos.
Risiko penetapan parameter yang tidak betul: Tempoh pengujian belakang atau tempoh purata bergerak boleh mempengaruhi pengiraan julat grid jika ditetapkan dengan tidak betul.
Risiko pasaran sistemik. Lebih sesuai untuk pasaran terhad pada julat dan bukannya pasaran trend jangka panjang.
Mengoptimumkan parameter grid. Mempertimbangkan secara komprehensif keadaan pasaran, kos dan lain-lain untuk mengoptimumkan bilangan grid, tempoh melihat semula dan lain-lain.
Memperkenalkan pelarasan julat grid dinamik. Sesuaikan julat grid apabila perubahan pasaran yang ketara berlaku.
Memasukan mekanisme stop loss. Tetapkan garis stop loss yang betul untuk mengehadkan kerugian. Boleh diselaraskan secara dinamik.
Tambah penapis menggunakan penunjuk lain seperti Bollinger Band, penunjuk trend dan lain-lain untuk mengelakkan perdagangan yang tidak betul.
Meningkatkan kecekapan penggunaan modal. Memperkenalkan analisis turun naik untuk mengurangkan perdagangan semasa tempoh yang stabil.
Strategi ini merealisasikan perdagangan julat yang boleh dikawal risiko dengan memanfaatkan prinsip perdagangan grid. Pengiraan grid automatik dan pengedaran seragam menawarkan kelebihan yang sesuai dengan pelbagai pasaran melalui penyesuaian parameter. Risiko terhad dan mudah dikendalikan. Walau bagaimanapun, terdapat batasan dan peningkatan berterusan diperlukan untuk menyesuaikan diri dengan pasaran yang berkembang. Secara keseluruhan, strategi ini menyediakan pendekatan standard dan parameter untuk melaksanakan perdagangan grid.
/*backtest
start: 2023-09-12 00:00:00
end: 2023-10-12 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("(IK) Grid Script", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool) // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"]) // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1) // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound = input(group="Grid Bounds", title="(Manual) Upper Boundry", defval=0.285, type=input.float) // for manual grid bounds only. The upperbound price of your grid
i_lowerBound = input(group="Grid Bounds", title="(Manual) Lower Boundry", defval=0.225, type=input.float) // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty = input(group="Grid Lines", title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer) // how many grid lines are in your grid
strategy.initial_capital = 50000
f_getGridBounds(_bs, _bl, _bd, _up) =>
if _bs == "Hi & Low"
_up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl) * (1 - _bd)
else
avg = sma(close, _bl)
_up ? avg * (1 + _bd) : avg * (1 - _bd)
f_buildGrid(_lb, _gw, _gq) =>
gridArr = array.new_float(0)
for i=0 to _gq-1
array.push(gridArr, _lb+(_gw*i))
gridArr
f_getNearGridLines(_gridArr, _price) =>
arr = array.new_int(3)
for i = 0 to array.size(_gridArr)-1
if array.get(_gridArr, i) > _price
array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
array.set(arr, 1, i == 0 ? i : i-1)
break
arr
var upperBound = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound // upperbound of our grid
var lowerBound = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth = (upperBound - lowerBound)/(i_gridQty-1) // space between lines in our grid
var gridLineArr = f_buildGrid(lowerBound, gridWidth, i_gridQty) // an array of prices that correspond to our grid lines
var orderArr = array.new_bool(i_gridQty, false) // a boolean array that indicates if there is an open order corresponding to each grid line
var closeLineArr = f_getNearGridLines(gridLineArr, close) // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0) // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1) // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
for i = 0 to (array.size(gridLineArr) - 1)
if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
buyId = i
array.set(orderArr, buyId, true)
strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
if close > array.get(gridLineArr, i) and i != 0
if array.get(orderArr, i-1)
sellId = i-1
array.set(orderArr, sellId, false)
strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))
if i_autoBounds
upperBound := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
lowerBound := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
gridWidth := (upperBound - lowerBound)/(i_gridQty-1)
gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)
closeLineArr := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)