Strategi henti untung dan henti rugi Momentum dua hala
ChaoZhang
Gambaran keseluruhan
Strategi ini adalah pembesaran berdasarkan strategi kenaikan / penurunan berturut-turut yang dibina dalam TradingView. Ia mempunyai tetapan arah strategi yang fleksibel, yang boleh melakukan perdagangan terbalik. Di samping itu, ia mengintegrasikan pelbagai cara berhenti, seperti swing high / low, ATR stop loss dan tracking stop loss, dan tetapan berhenti yang sesuai. Ini membolehkan strategi ini untuk mendapatkan pengurusan risiko yang lebih baik, berdasarkan pada isyarat perdagangan asal.
Prinsip Strategi
Strategi ini menghasilkan isyarat beli dan jual dengan menilai jumlah kenaikan atau penurunan K secara berturut-turut. Pengguna boleh menetapkan jumlah garis K naik secara berturut-turut yang diperlukan untuk menghasilkan isyarat beli, dan jumlah garis K turun secara berturut-turut yang diperlukan untuk isyarat jual.
Pada masa yang sama, strategi menambah tetapan untuk menukar perdagangan. Setelah membuka perdagangan, isyarat beli akan berubah menjadi isyarat jual, dan isyarat jual juga akan berubah menjadi isyarat beli, sehingga selesai menukar perdagangan.
Strategi ini menyokong kedudukan kosong terbalik secara langsung untuk masuk dan keluar, yang dapat mengurangkan ketidakupayaan untuk berdagang ketika tidak ada kedudukan.
Dalam hal halangan dan hentian, strategi menyediakan tiga pilihan hentian yang boleh dipilih untuk mengayunkan tinggi / rendah, ATR dan strategi yang terbina dalam. Cara berhenti akan digabungkan dengan arah memegang kedudukan, secara automatik memilih jurang terendah atau puncak tertinggi sebagai titik berhenti radikal, atau menetapkan harga berhenti berdasarkan dinamik ATR.
Jika anda mengaktifkan penjejakan hentian, strategi ini dapat meningkatkan jarak hentian apabila rugi, mengurangkan jarak hentian apabila untung, dan mencapai penjejakan automatik.
Analisis kelebihan
Kelebihan utama strategi ini adalah fleksibiliti yang boleh disesuaikan dengan keadaan pasaran yang berbeza, seperti berikut:
- Parameter penyaringan jual beli yang boleh disesuaikan, menyesuaikan diri dengan trend dan keadaan goyah
- Sokongan untuk bertukar-tukar, mengikut keperluan
- Menetapkan kedudukan terbuka terbalik langsung untuk mengurangkan tempoh kosong
- Mengintegrasikan pelbagai cara untuk menghentikan kerugian, boleh dipilih mengikut keperluan
- Trace Stop Loss, Stop Loss Automatik boleh diaktifkan
Analisis risiko
Risiko utama strategi ini adalah bahawa terlalu banyak seting K-line berturut-turut boleh menyebabkan peluang perdagangan yang hilang, dan risiko seting stop loss yang terlalu radikal menyebabkan peningkatan kerugian. Cadangan terhadap risiko adalah sebagai berikut:
- Sesuaikan parameter jumlah K-baris naik/turun, jangan terlalu radikal
- Uji pelbagai cara untuk menghentikan kerugian dan pilih yang paling sesuai
- Pengaturan yang berhati-hati untuk mengelakkan kerugian yang berlebihan
Arah pengoptimuman
Strategi ini masih boleh dioptimumkan lagi:
- Jumlah garis K naik/turun yang boleh disesuaikan secara dinamik berdasarkan ATR atau kadar turun naik
- Boleh menguji kesan parameter Stop Loss Stop Loss Ratio pada tempoh pemegangan yang berbeza
- Anda boleh menetapkan penapis terbuka untuk mengelakkan penembusan palsu.
- Anda boleh menambah penilaian tambahan untuk meningkatkan kualiti isyarat.
ringkaskan
Strategi ini adalah pengembangan yang bermanfaat kepada strategi acuan, yang membolehkan anda mengawal risiko dengan lebih baik dan mendapatkan cara perdagangan yang lebih fleksibel. Ini adalah strategi Momentum yang berkesan yang mudah dioptimumkan dan tetap.
/*backtest
start: 2023-01-07 00:00:00
end: 2023-08-30 05:20:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// Extension of the built-in strategy by Tradingview. The strategy buys after an X amount of
// consecutive bullish bars and viceversa for selling. This logic can be reversed and a Stop Loss
// with Take Profit can be added. There's also an option to adapt the SL into a Trailing Stop.
//@version=4
strategy("Consecutive Up/Down Strategy with Reverse",
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-------------------")
consecutiveBarsUp = input(3)
consecutiveBarsDown = input(4)
/////////////////////// 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=2, 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(5, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(true, 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 = na
float ShortStop = na
float StratTP = na
float StratSTP = na
/////////////////////// STRATEGY LOGIC /////////////////////////////////////////
price = close
ups = 0.0
ups := price > price[1] ? nz(ups[1]) + 1 : 0
dns = 0.0
dns := price < price[1] ? nz(dns[1]) + 1 : 0
BUY=ups >= consecutiveBarsUp and bar_index > 40
SELL=dns >= consecutiveBarsDown and bar_index > 40
//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)