Sumber daya yang dimuat... Pemuatan...

Strategi Look-Up dan Look-Down Berdasarkan Saluran Harga Internal

Penulis:ChaoZhangTanggal: 2023-12-11 15:56:28
Tag:

Gambaran umum

Strategi ini menggunakan saluran harga internal untuk menentukan tren harga di masa depan dan termasuk dalam strategi trend berikut. Ketika harga membentuk sejumlah saluran fluktuasi harga internal, itu dinilai sebagai sinyal pembalikan tren untuk membuat entri panjang atau pendek.

Prinsip Strategi

Strategi menentukan pembentukan saluran internal sesuai dengan hubungan ukuran antara harga tertinggi dan terendah dari dua candlestick sebelumnya. Ketika sejumlah candlestick memenuhi kondisi bahwa harga tertinggi lebih rendah dari harga tertinggi dari candlestick sebelumnya dan harga terendah lebih tinggi dari harga terendah dari candlestick sebelumnya, saluran harga internal diidentifikasi.

Ketika saluran internal diidentifikasi, strategi juga menilai arah saluran. Jika saluran internal bullish, sinyal masuk panjang dihasilkan. Jika saluran internal bearish, sinyal masuk pendek dihasilkan. Oleh karena itu, ini adalah strategi perdagangan bidirectional.

Untuk menyaring sinyal palsu, indikator rata-rata bergerak juga diperkenalkan. sinyal perdagangan yang sebenarnya hanya dihasilkan ketika harga berada di atas atau di bawah garis rata-rata bergerak.

Setelah masuk, titik stop-loss dan take-profit juga dapat diatur sesuai dengan pilihan pengguna. Ada tiga metode stop loss yang tersedia: stop loss titik tetap, ATR stop loss, stop loss tertinggi / terendah sebelumnya. Take profit ditetapkan sesuai rasio risiko / imbalan. Ini dapat mengunci keuntungan sampai batas tertentu dan mengendalikan risiko.

Analisis Keuntungan

Keuntungan terbesar dari strategi ini adalah kemampuannya yang kuat untuk mengidentifikasi titik pembalikan tren. Ketika harga membentuk sejumlah saluran internal tertentu, itu seringkali menandakan bahwa pergerakan harga naik/turun yang relatif besar akan terjadi.

Selain itu, konfigurasi strategi itu sendiri sangat kuat. Pengguna dapat secara bebas memilih parameter seperti jumlah saluran internal, siklus rata-rata bergerak, metode stop loss / take profit, dll. Ini memberikan fleksibilitas yang besar untuk produk dan gaya perdagangan yang berbeda.

Akhirnya, filter rata-rata bergerak dan pengaturan stop-loss / take-profit yang diperkenalkan dalam strategi juga sangat mengurangi risiko perdagangan.

Analisis Risiko

Risiko terbesar dari strategi ini adalah probabilitas yang relatif tinggi dari penilaian tren yang salah. Saluran internal tidak dapat sepenuhnya menentukan pembalikan harga, ada kemungkinan penilaian yang salah. Jika jumlah yang ditentukan tidak cukup, sinyal palsu dapat terjadi.

Selain itu, strategi ini benar-benar tidak berguna di pasar sisi atau volatile. Ketika harga turun naik tanpa menetapkan tren, strategi akan terus menghasilkan sinyal yang salah. Ini ditentukan oleh mekanisme strategi.

Akhirnya, jika stop loss diatur terlalu konservatif, strategi mungkin tidak dapat memegang posisi cukup lama untuk menangkap keuntungan dalam tren utama.

Arahan Optimasi

Ruang pengoptimalan strategi ini masih cukup besar. Beberapa arah pengoptimalan yang mungkin termasuk:

Mengoptimalkan jumlah dan pola saluran internal. Uji efek perdagangan di bawah jumlah yang berbeda atau pengaturan kombinasi yang berbeda.
Optimalkan parameter siklus rata-rata bergerak untuk lebih menentukan arah tren.
Tambahkan filter indikator lainnya. Misalnya, memperkenalkan Bollinger Bands dan hanya menghasilkan sinyal perdagangan ketika harga menerobos rel atas atau bawah Band.
Mengoptimalkan parameter stop loss / take profit untuk memungkinkan strategi untuk memegang posisi lebih lama. Dengan demikian menangkap keuntungan dalam tren super.

Secara umum, keberadaan strategi ini terletak pada keakuratan penilaian tren. Selama keakuratan penilaian dapat dijamin, dikombinasikan dengan pengaturan manajemen risiko yang tepat, perdagangan algoritmik yang efektif dapat dilakukan.

Kesimpulan

Secara singkat, strategi ini adalah strategi perdagangan kuantitatif yang menentukan tren harga di masa depan berdasarkan saluran harga internal. Ini menggabungkan metode penilaian tren berikut dan pembalikan tren dan memiliki keuntungan tertentu. Tetapi juga ada ruang untuk optimasi untuk memenuhi produk dan lingkungan perdagangan tertentu. Setelah optimasi parameter, ini dapat menjadi salah satu strategi perdagangan kuantitatif yang paling ideal.

/*backtest
start: 2023-12-03 00:00:00
end: 2023-12-10 00:00:00
period: 3m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// From "Day Trading Cryptocurrency 
// Strategies, Tactics, Mindset, and Tools Required To Build Your 
// New Income Stream"
// by Phil C. Senior

// "Inside bars are a two -bar pattern. They can indicate either a continuation of the 
// existing move or a reversal. A continuation occurs when there is no significant 
// support or resistance level in sight, while a reversal occurs close to a strong sup- 
// port or resistance level...
// ...A lot of traders are aware of inside bars but few manage to make money with 
// them. Why is this so? It goes back to interpreting price action. A lot of traders look 
// to trade in geometric ways. What I mean is that they search for fancy shapes on a 
// chart and think that this is what represents true price action. 
// This is not the case. A shape is just a shape. The formation by itself means 
// nothing unless underlying order flow backs it up. This is why it’s extremely impor- 
// tant that you look for inside bars when a trend is already in place. The best place to 
// look for them is in the beginning of trends."

// © tweakerID

//@version=4
strategy("Inside Bar Strategy w/ SL", 
     overlay=true, 
     default_qty_type=strategy.percent_of_equity, 
     default_qty_value=100, 
     initial_capital=10000, 
     commission_value=0.04, 
     calc_on_every_tick=false, 
     slippage=0)

direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))

/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")  

i_NBars = input(defval=1, type=input.integer, title="# Of Inside Bars in pattern", options=[1, 2, 3, 4])
i_BarsDirection = input(false, title="Only trade using complete bullish or bearish patterns")
i_MAFilter = input(true, title="Use MA Trend Filter")
i_MALen = input(65, title="MA Length")

/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")  

// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=1, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(5, step=.1, title="ATR Multiple")
i_TPRRR = input(2, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(false, title="Trailing Stop")

// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1] 
 or strategy.position_size < strategy.position_size[1]

// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na 
entry_HH_price = strategy.position_size < 0 ? HH_price : na 
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR

// ATR Stop
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na 
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na 
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR


// Strategy Stop
float LongStop = valuewhen(bought,low[1],0)*(1-i_PercIncrement)
float ShortStop = valuewhen(bought,high[1],0)*(1+i_PercIncrement)
float StratTP = na
float StratSTP = na

/////////////////////// STRATEGY LOGIC /////////////////////////////////////////

MAFilter=close > sma(close, i_MALen)
plot(i_MAFilter ? sma(close, i_MALen) : na)
bullBar=close > open
bearBar=close < open
contbullBar=barssince(not bullBar) >= (i_NBars+1)
contbearBar=barssince(not bearBar) >= (i_NBars+1)

InsideBar(NBars) =>
    Inside1Bar=high < high[1] and low > low[1] 
    Inside2Bar=high < high[2] and low > low[2] and Inside1Bar
    Inside3Bar=high < high[3] and low > low[3] and Inside1Bar and Inside2Bar
    Inside4Bar=high < high[4] and low > low[4] and Inside1Bar and Inside2Bar and Inside3Bar
    if NBars == 1
        inside1Bar=Inside1Bar
        [inside1Bar]
    else if NBars == 2
        inside2Bar=Inside2Bar
        [inside2Bar]
    else if NBars == 3
        inside3Bar=Inside3Bar   
        [inside3Bar]
    else if NBars == 4
        inside4Bar=Inside4Bar
        [inside4Bar]
    else
        [na]
[insideBar] = InsideBar(i_NBars) 
    
bullInsideBar=bar_index > 40 and insideBar and bullBar 
     and (i_BarsDirection ? contbullBar : true) and (i_MAFilter ? MAFilter : true)
bearInsideBar=bar_index > 40 and insideBar and bearBar 
     and (i_BarsDirection ? contbearBar : true) and (i_MAFilter ? not MAFilter : true)

BUY = bullInsideBar
SELL = bearInsideBar

//Debugging Plots
plot(contbullBar ? 1:0, transp=100, title="contbullBar")
plot(contbearBar ? 1:0, transp=100, title="contbearBar")

//Trading Inputs
DPR=input(true, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")

// Entries
if reverse
    if not DPR
        strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
    else     
        strategy.entry("long", strategy.long, when=SELL)
        strategy.entry("short", strategy.short, when=BUY)
else
    if not DPR 
        strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
    else
        strategy.entry("long", strategy.long, when=BUY)
        strategy.entry("short", strategy.short, when=SELL)

SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP

//TrailingStop
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
 -strategy.position_avg_price
trailOffset     = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
    tstop := high- trailOffset - dif
    if tstop<tstop[1]
        tstop:=tstop[1]
else
    tstop := na
StrailOffset     = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0 
 and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
    Ststop := low+ StrailOffset + Sdif
    if Ststop>Ststop[1]
        Ststop:=Ststop[1]
else
    Ststop := na

strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL, when=i_SL)

/////////////////////// PLOTS //////////////////////////////////////////////////

plot(i_SL and strategy.position_size > 0 and not TS ? SL : i_SL and strategy.position_size > 0 and TS ? tstop : na , title='SL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size < 0 and not TS ? SSL : i_SL and strategy.position_size < 0 and TS ? Ststop : na , title='SSL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(i_SL and strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar, 
 color=color.green, title="Bullish Setup", size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar, 
 color=color.red, title="Bearish Setup", size=size.auto)

Lebih banyak

2019 FMZ - Semua hak dilindungi