Strategi Blok Tren
ChaoZhang
Ringkasan
Trend blocking adalah strategi perdagangan yang dilakukan berdasarkan persentase perubahan harga atau titik bouncing. Strategi ini dapat menampilkan tren lokal dan titik pivot secara jelas pada grafik. Ini adalah alat yang sangat berguna untuk melacak arah harga.
Prinsip
Perhitungan strategi ini didasarkan pada persentase perubahan harga atau defisiensi titik bouncing (diekspresikan dalam parameter defisiensi pivot) dan ditampilkan dalam bentuk garis diagonal pada grafik.
Setiap baris terdiri dari garis tengah, garis batas atas, dan garis batas bawah:
Garis tengah acuan sama dengan batas atas atau batas bawah dari baris sebelumnya atau baris berikutnya. Jika harga berubah dengan cepat dalam satu interval waktu, maka garis tengah acuan baris saat ini akan lebih besar dari batas atas baris sebelumnya atau lebih kecil dari batas bawah baris berikutnya dengan jumlah yang sama sekali berbeda, tergantung pada arah perubahan harga. Pada awal perhitungan, garis tengah acuan sama dengan nilai awal baris pertama.
Parameter kuantitas pivot menentukan deviasi dari batas atas atau batas bawah dari arah perubahan harga. Parameter pivot reversal menentukan deviasi dari arah perubahan harga.
Aturan untuk membuat baris baru:
Jika harga penutupan ≥ batas atas dan harga penutupan > batas terbuka, batas atas akan bergerak ke atas secara bertahap, batas bawah juga akan bergerak ke atas tetapi lebih kecil.
Jika harga minimum ≤ batas bawah dan harga penutupan < harga pembukaan, batas bawah akan bergerak ke bawah secara bertahap, batas atas juga akan bergerak ke bawah tetapi dengan margin yang lebih kecil.
Dengan menyesuaikan deviasi, Anda dapat dengan jelas melihat tren lokal dan titik balik pada grafik. Ini adalah alat yang sangat berguna untuk melacak pergerakan harga.
Analisis Keunggulan
Untuk menunjukkan tren perubahan harga secara visual, identifikasi resistensi dukungan dengan jelas.
Garis diagonal dapat dengan jelas menunjukkan intensitas dari terobosan dan ruang lingkup dari resonansi.
Tren dengan intensitas yang berbeda dapat diidentifikasi dengan menyesuaikan kemiringan pada garis sudut.
Ini adalah salah satu cara yang paling efektif untuk menemukan dukungan dan resistensi yang lebih besar.
Untuk melihat perubahan harga yang cepat, Anda dapat menyesuaikan posisi Anda.
Analisis risiko
Garis diagonal tidak dapat secara akurat memprediksi pergerakan harga selanjutnya.
Perlu diperhatikan bahwa pada saat ini ada beberapa perpotongan dalam tren yang mungkin terjadi antara garis sudut dan harga sebenarnya.
Tidak dapat digunakan sebagai strategi yang terpisah, dan perlu digabungkan dengan indikator lain untuk menilai tren besar.
Perlu diperhatikan bahwa penyesuaian parameter yang tidak tepat dapat menyebabkan perdagangan yang terlalu sering.
Kemungkinan pembalikan alarm diperlukan saat panggilan balik, tidak dapat dilacak secara membabi buta.
Anda dapat mengurangi ukuran posisi Anda sesuai dengan kebutuhan, dengan referensi pada indikator lain sebagai penilaian tambahan, untuk melakukan operasi di bawah tren besar.
Arah optimasi
Modul manajemen posisi dapat ditambahkan untuk menyesuaikan posisi secara dinamis pada berbagai tahap tren.
Anda dapat menggunakan indikator volatilitas untuk menurunkan posisi Anda saat volatilitas meningkat.
Stop loss dapat diatur berdasarkan rasio penarikan untuk mengendalikan kerugian tunggal.
Filter dapat ditambahkan untuk menghentikan perdagangan jika ada deviasi harga.
Skala diagonal dapat dibagi menjadi beberapa tingkatan untuk mengidentifikasi perubahan tren dengan intensitas yang berbeda.
Dengan menyesuaikan posisi secara dinamis, mengatur kondisi stop loss dan filter, Anda dapat lebih stabil melacak tren harga.
Meringkaskan
Strategi blok tren menggunakan garis diagonal untuk secara intuitif menunjukkan perubahan tren harga, dapat dengan jelas mengidentifikasi titik-titik resistensi dukungan dan titik-titik pemecahan. Tetapi tidak dapat bergantung pada penilaian yang independen dari garis diagonal, perlu didukung dengan indikator lain untuk analisis komprehensif, sambil mengendalikan risiko. Ini adalah alat bantu yang sangat berharga yang dapat membantu pedagang untuk lebih memahami irama pasar.
/*backtest
start: 2023-10-06 00:00:00
end: 2023-11-05 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
// **********************************************************************************
// This code is invented and written by @StCogitans.
// The idea presented in this code and the rights to this code belong to @StCogitans.
// © https://www.tradingview.com/u/StCogitans
//
// Description.
// Sizeblock - a price change strategy in the form of diagonal rows.
// **********************************************************************************
// STRATEGY
string NAME = 'Sizeblock'
string ACRONYM = 'SB'
bool OVERLAY = true
int PYRAMIDING = 0
string QTY_TYPE = strategy.percent_of_equity
float QTY_VALUE = 100
float CAPITAL = 100
string COM_TYPE = strategy.commission.percent
float COM_VALUE = 0.1
bool ON_CLOSE = false
bool BAR_MAGNIFIER = false
bool OHLC = true
strategy(NAME, ACRONYM, OVERLAY, pyramiding=PYRAMIDING, default_qty_type=QTY_TYPE, default_qty_value=QTY_VALUE, initial_capital=CAPITAL, commission_type=COM_TYPE, commission_value=COM_VALUE, process_orders_on_close=ON_CLOSE, use_bar_magnifier=BAR_MAGNIFIER, fill_orders_on_standard_ohlc=OHLC)
// ARGUMENTS
// Datetime
DTstart = input(timestamp("01 Jan 2000 00:00 +0000"), 'Start time', group='Datetime')
DTfinish = input(timestamp("01 Jan 2080 23:59 +0000"), 'Finish time', group='Datetime')
DTperiod = true
// Main
dev_source = input.string('Close', title='Source', options=["Close", "HighLow"], tooltip='Price data for settlement.', group='Main')
dev_type = input.string('Percentage', title='Deviation', options=['Percentage', 'Ticks'], tooltip='The type of deviation to calculate.', group='Main')
dev_value = input.float(1, title='Quantity', minval=0.001, step=0.01, tooltip='Quantity to be calculated.', group='Main')
dev_back = input.float(2, title='U-turn', minval=0.001, step=0.01, tooltip='Quantity for reversal.', group='Main')
mode = input.string('Limit', title='Positions', options=['Limit', 'Market'], tooltip='Limit or market orders.', group='Main')
direct = input.string('All', title='Direction', options=['All', 'Buy', 'Sell'], tooltip='The type of positions to be opened.', group='Main')
swapping = input.bool(false, title='Swapping', tooltip='Swap points to open a new position.', group='Main')
// CALCULATION SYSTEM
Assembling(s, t, v, vb) =>
float a = open
float b = close
float c = s == "HighLow" ? math.round_to_mintick(high) : math.round_to_mintick(b)
float d = s == "HighLow" ? math.round_to_mintick(low) : math.round_to_mintick(b)
float x = math.round_to_mintick(a)
x := nz(x[1], x)
float _v = t == "Ticks" ? syminfo.mintick * v : v
float _vb = t == "Ticks" ? syminfo.mintick * vb : vb
float h = t == "Ticks" ? math.round_to_mintick(x + _v) : math.round_to_mintick(x * (1 + _v / 100))
float l = t == "Ticks" ? math.round_to_mintick(x - _v) : math.round_to_mintick(x * (1 - _v / 100))
h := nz(h[1], h)
l := nz(l[1], l)
if t == "Ticks"
if c >= h and b > a
while c >= h
x := h
h := math.round_to_mintick(h + _v)
l := math.round_to_mintick(x - _vb)
if d <= l and b < a
while d <= l
x := l
l := math.round_to_mintick(l - _v)
h := math.round_to_mintick(x + _vb)
else if t == "Percentage"
if c >= h and b > a
while c >= h
x := h
h := math.round_to_mintick(h * (1 + _v / 100))
l := math.round_to_mintick(x * (1 - _vb / 100))
if d <= l and b < a
while d <= l
x := l
l := math.round_to_mintick(l * (1 - _v / 100))
h := math.round_to_mintick(x * (1 + _vb / 100))
[x, h, l]
[lx, lh, ll] = Assembling(dev_source, dev_type, dev_value, dev_back)
// PLOT
// Lines
plot_up = plot(lh, color=color.new(color.green, 50), style=plot.style_line, linewidth=1)
plot_main = plot(lx, color=color.new(color.silver, 50), style=plot.style_line, linewidth=1)
plot_down = plot(ll, color=color.new(color.red, 50), style=plot.style_line, linewidth=1)
// Areas
fill(plot_up, plot_main, lh, lx, color.new(color.teal, 80), color.new(color.teal, 80))
fill(plot_main, plot_down, lx, ll, color.new(color.maroon, 80), color.new(color.maroon, 80))
// TRADING
// Alert variables
int Action = -1
int PosType = -1
int OrderType = -1
float Price = -1.0
// Direction variables
bool ifBuy = direct == "All" or direct == "Buy" ? true : false
bool ifSell = direct == "All" or direct == "Sell" ? true : false
// Market entries
if (strategy.closedtrades + strategy.opentrades == 0 or mode == "Market") and DTperiod
if ((swapping and lx < nz(lx[1], lx)) or (not swapping and lx > nz(lx[1], lx))) and ifBuy
Action := 1
PosType := 1
OrderType := 1
Price := math.round_to_mintick(close)
strategy.entry('Long', strategy.long)
if ((swapping and lx > nz(lx[1], lx)) or (not swapping and lx < nz(lx[1], lx))) and ifSell
Action := 2
PosType := 2
OrderType := 1
Price := math.round_to_mintick(close)
strategy.entry('Short', strategy.short)
// Closing positions by market
if DTperiod and mode == "Market"
if direct == "Buy" and strategy.position_size > 0
if swapping and lx > nz(lx[1], lx)
Action := 2
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Long', comment='Close')
if not swapping and lx < nz(lx[1], lx)
Action := 2
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Long', comment='Close')
if direct == "Sell" and strategy.position_size < 0
if swapping and lx < nz(lx[1], lx)
Action := 1
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Short', comment='Close')
if not swapping and lx > nz(lx[1], lx)
Action := 1
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Short', comment='Close')
// Limit entries and exits
if swapping and DTperiod and mode == "Limit"
if strategy.position_size < 0
Action := 1
PosType := 1
OrderType := 2
Price := ll
if ifBuy
strategy.entry('Long', strategy.long, limit=ll)
else
PosType := 3
strategy.exit('Exit', limit=ll)
if strategy.position_size > 0
Action := 2
PosType := 2
OrderType := 2
Price := lh
if ifSell
strategy.entry('Short', strategy.short, limit=lh)
else
PosType := 3
strategy.exit('Exit', limit=lh)
if strategy.closedtrades + strategy.opentrades > 0 and strategy.position_size == 0
if ifBuy
Action := 1
PosType := 1
OrderType := 2
Price := ll
strategy.entry('Long', strategy.long, limit=ll)
if ifSell
Action := 2
PosType := 2
OrderType := 2
Price := lh
strategy.entry('Short', strategy.short, limit=lh)
if not swapping and DTperiod and mode == "Limit"
if strategy.position_size < 0
Action := 1
PosType := 1
OrderType := 2
Price := lh
if ifBuy
strategy.entry('Long', strategy.long, stop=lh)
else
PosType := 3
strategy.exit('Exit', stop=lh)
if strategy.position_size > 0
Action := 2
PosType := 2
OrderType := 2
Price := ll
if ifSell
strategy.entry('Short', strategy.short, stop=ll)
else
PosType := 3
strategy.exit('Exit', stop=ll)
if strategy.closedtrades + strategy.opentrades > 0 and strategy.position_size == 0
if ifBuy
Action := 1
PosType := 1
OrderType := 2
Price := lh
strategy.entry('Long', strategy.long, stop=lh)
if ifSell
Action := 2
PosType := 2
OrderType := 2
Price := ll
strategy.entry('Short', strategy.short, stop=ll)
// Everything is closed and canceled
if not DTperiod
strategy.cancel_all()
strategy.close_all(comment='Close')
// Alerts
// Convert to string variables
string Action_Txt = Action == 1 ? "Buy" : Action == 2 ? "Sell" : na
string PosType_Txt = PosType == 1 ? "Long" : PosType == 2 ? "Short" : PosType == 3 ? "Flat" : na
string OrderType_Txt = OrderType == 1 ? "Market" : OrderType == 2 ? "Limit" : na
string Price_Txt = Price > 0 ? str.tostring(Price) : na
// Output
if not (Action == nz(Action[1], Action) and Price == nz(Price[1], Price) and OrderType == nz(OrderType[1], OrderType)) and DTperiod
alert('{"pair": "' + syminfo.ticker + '", "direction": "' + Action_Txt + '", "entertype": "' + OrderType_Txt + '", "position": "' + PosType_Txt + '", "price": "' + Price_Txt + '"}')
// *********************
// Good job, Soldier! ;>
// *********************