RSI Garis Ganjaran Garis Ganjaran Ganjaran Ganjaran

Penulis:ChaoZhang, Tarikh: 2023-10-25 11:57:46
Tag:

Ringkasan

RSI Dual-rail Oscillation Line Long and Short Bi-directional Trading Strategy adalah strategi perdagangan dua arah yang menggunakan penunjuk RSI. Ia melaksanakan pembukaan dan penutupan kedudukan dua arah yang cekap melalui prinsip overbought dan oversold RSI, digabungkan dengan tetapan dua rel dan isyarat perdagangan purata bergerak.

Logika Strategi

Strategi ini terutamanya membuat keputusan perdagangan berdasarkan prinsip overbought dan oversold dari penunjuk RSI. Ia mula-mula mengira nilai RSI vrsi, serta rel atas sn dan rel bawah ln dari rel dua. Isyarat panjang dihasilkan apabila nilai RSI melintasi bawah rel bawah ln, dan isyarat pendek dihasilkan apabila nilai RSI melintasi di atas rel atas sn.

Strategi ini juga mengesan kenaikan dan kejatuhan lilin untuk menghasilkan isyarat panjang dan pendek. Khususnya, isyarat panjang longLocic dihasilkan apabila lilin pecah ke atas, dan isyarat pendek shortLogic dihasilkan apabila lilin pecah ke bawah. Di samping itu, strategi ini menyediakan suis parameter untuk pergi panjang sahaja, pendek sahaja, atau isyarat terbalik.

Selepas menghasilkan isyarat panjang dan pendek, strategi akan mengira jumlah isyarat untuk mengawal bilangan pembukaan. Peraturan piramid yang berbeza boleh ditetapkan melalui parameter. Syarat penutupan kedudukan termasuk mengambil keuntungan, hentikan kerugian, hentikan kerugian, dan lain-lain, dengan peratusan keuntungan dan kerugian yang boleh disesuaikan.

Ringkasnya, strategi itu mengintegrasikan penunjuk RSI, crossover purata bergerak, piramida statistik, berhenti keuntungan dan berhenti kerugian dan cara teknikal lain untuk mencapai perdagangan dua arah panjang dan pendek automatik.

Kelebihan Strategi

Menggunakan prinsip overbought dan oversold RSI untuk mewujudkan kedudukan panjang dan pendek pada tahap yang munasabah.
Rel ganda menghalang isyarat yang salah. Rel atas menghalang penutupan awal kedudukan panjang, sementara rel bawah menghalang penutupan awal kedudukan pendek.
Isyarat perdagangan purata bergerak menapis pecah palsu. Isyarat hanya dihasilkan apabila harga memecahkan purata bergerak, mengelakkan isyarat palsu.
Hitung isyarat dan masa piramid untuk mengawal risiko.
Peratusan keuntungan dan kerugian yang boleh disesuaikan untuk keuntungan dan risiko yang boleh dikawal.
Mengekalkan stop loss untuk mengunci keuntungan lebih lanjut.
Pergi panjang sahaja, pendek sahaja atau isyarat terbalik untuk menyesuaikan diri dengan persekitaran pasaran yang berbeza.
Sistem perdagangan automatik mengurangkan kos operasi manual.

Risiko Strategi

Risiko kegagalan pembalikan RSI wujud. RSI memasuki zon overbought atau oversold tidak semestinya berbalik.
Seting yang tidak betul boleh menyebabkan stop loss atau mengambil keuntungan yang lebih awal.
Bergantung pada penunjuk teknikal mempunyai risiko pengoptimuman. Parameter penunjuk yang tidak betul memberi kesan negatif terhadap prestasi strategi.
Pencetakan pelbagai keadaan secara serentak berisiko kehilangan perdagangan.
Sistem perdagangan automatik mempunyai risiko ralat yang tidak normal.

Untuk menangani risiko di atas, parameter boleh dioptimumkan, strategi berhenti keuntungan dan kerugian boleh diselaraskan, penapis kecairan boleh ditambahkan, logik isyarat boleh ditingkatkan, dan pemantauan pengecualian boleh ditingkatkan.

Arahan pengoptimuman

Pengoptimuman parameter ujian parameter RSI pada jangka masa yang berbeza.
Uji seting peratusan keuntungan dan stop loss yang berbeza.
Tambah penapis jumlah atau keuntungan untuk mengelakkan kecairan yang tidak mencukupi.
Mengoptimumkan logik isyarat dan meningkatkan persilangan purata bergerak.
Ujian semula dalam beberapa tempoh masa untuk mengesahkan kestabilan.
Pertimbangkan untuk menambah penunjuk lain untuk meningkatkan kualiti isyarat.
Menggabungkan strategi saiz kedudukan.
Tambah penanganan pengecualian dan pemantauan ralat.
Mengoptimumkan algoritma penangguhan automatik.
Pertimbangkan untuk menggabungkan pembelajaran mesin untuk meningkatkan strategi.

Ringkasan

RSI Dual-rail Oscillation Line Long dan Short Bi-directional Trading Strategy mengintegrasikan penunjuk RSI, prinsip pembukaan dan hentian kerugian statistik dan alat teknikal lain untuk mencapai perdagangan bi-directional automatik. Strategi ini sangat disesuaikan untuk pengguna menyesuaikan parameter dengan persekitaran pasaran yang berbeza.

/*backtest
start: 2023-09-24 00:00:00
end: 2023-10-24 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
// Learn more about Autoview and how you can automate strategies like this one here: https://autoview.with.pink/
// strategy("Autoview Build-a-bot - 5m chart", "Strategy", overlay=true, pyramiding=2000, default_qty_value=10000)
// study("Autoview Build-a-bot", "Alerts")

///////////////////////////////////////////////
//* Backtesting Period Selector | Component *//
///////////////////////////////////////////////

//* https://www.tradingview.com/script/eCC1cvxQ-Backtesting-Period-Selector-Component *//
//* https://www.tradingview.com/u/pbergden/ *//
//* Modifications made *//

testStartYear = input(1, "Backtest Start Year") 
testStartMonth = input(11, "Backtest Start Month")
testStartDay = input(10, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(77777777, "Backtest Stop Year")
testStopMonth = input(11, "Backtest Stop Month")
testStopDay = input(15, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)

testPeriod() => true

/////////////////////////////////////
//* Put your strategy logic below *//
/////////////////////////////////////
RSIlength = input(1,title="RSI Period Length") 
price = close
vrsi = (rsi(price, RSIlength))
src = close
len = input(2, minval=1, title="Length")

up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))

rsin = input(12)
sn = 100 - rsin
ln = 0 + rsin

// Put your long and short rules here
longLocic = crossunder(rsi, ln)
shortLogic = crossover(rsi, sn)

//////////////////////////
//* Strategy Component *//
//////////////////////////

isLong = input(true, "Longs Only")
isShort = input(false, "Shorts Only")
isFlip = input(false, "Flip the Opens")

long = longLocic
short = shortLogic

if isFlip
    long := shortLogic
    short := longLocic
else
    long := longLocic
    short := shortLogic

if isLong
    long := long
    short := na

if isShort
    long := na
    short := short
    
////////////////////////////////
//======[ Signal Count ]======//
////////////////////////////////

sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])

if long
    sectionLongs := sectionLongs + 1
    sectionShorts := 0

if short
    sectionLongs := 0
    sectionShorts := sectionShorts + 1

//////////////////////////////
//======[ Pyramiding ]======//
//////////////////////////////

pyrl = input(2, "Pyramiding less than") // If your count is less than this number
pyre = input(1, "Pyramiding equal to") // If your count is equal to this number
pyrg = input(1000000, "Pyramiding greater than") // If your count is greater than this number

longCondition = long and sectionLongs <= pyrl or long and sectionLongs >= pyrg or long and sectionLongs == pyre ? 1 : 0 and vrsi < 20
shortCondition = short and sectionShorts <= pyrl or short and sectionShorts >= pyrg or short and sectionShorts == pyre ? 1 : 0

////////////////////////////////
//======[ Entry Prices ]======//
////////////////////////////////

last_open_longCondition = na
last_open_shortCondition = na
last_open_longCondition := longCondition ? close : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close : nz(last_open_shortCondition[1])

////////////////////////////////////
//======[ Open Order Count ]======//
////////////////////////////////////

sectionLongConditions = 0
sectionLongConditions := nz(sectionLongConditions[1])
sectionShortConditions = 0
sectionShortConditions := nz(sectionShortConditions[1])

if longCondition
    sectionLongConditions := sectionLongConditions + 1
    sectionShortConditions := 0

if shortCondition
    sectionLongConditions := 0
    sectionShortConditions := sectionShortConditions + 1
    
///////////////////////////////////////////////
//======[ Position Check (long/short) ]======//
///////////////////////////////////////////////

last_longCondition = na
last_shortCondition = na
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])

in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition

/////////////////////////////////////
//======[ Position Averages ]======//
/////////////////////////////////////

totalLongs = 0.0
totalLongs := nz(totalLongs[1])
totalShorts = 0.0
totalShorts := nz(totalShorts[1])
averageLongs = 0.0
averageLongs := nz(averageLongs[1])
averageShorts = 0.0
averageShorts := nz(averageShorts[1]) 

if longCondition
    totalLongs := totalLongs + last_open_longCondition
    totalShorts := 0.0

if shortCondition
    totalLongs := 0.0
    totalShorts := totalShorts + last_open_shortCondition

averageLongs := totalLongs / sectionLongConditions
averageShorts := totalShorts / sectionShortConditions

/////////////////////////////////
//======[ Trailing Stop ]======//
/////////////////////////////////

isTS = input(false, "Trailing Stop")
tsi = input(100, "Activate Trailing Stop Price (%). Divided by 100 (1 = 0.01%)") / 100 
ts = input(100, "Trailing Stop (%). Divided by 100 (1 = 0.01%)") / 100

last_high = na
last_low = na
last_high_short = na
last_low_short = na
last_high := not in_longCondition ? na : in_longCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_high_short := not in_shortCondition ? na : in_shortCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_shortCondition ? na : in_shortCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
last_low_short := not in_longCondition ? na : in_longCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])

long_ts = isTS and not na(last_high) and low <= last_high - last_high / 100 * ts and longCondition == 0 and last_high >= averageLongs + averageLongs / 100 * tsi
short_ts = isTS and not na(last_low) and high >= last_low + last_low / 100 * ts and shortCondition == 0 and last_low <= averageShorts - averageShorts/ 100 * tsi

///////////////////////////////
//======[ Take Profit ]======//
///////////////////////////////

isTP = input(true, "Take Profit")
tp = input(125, "Take Profit (%). Divided by 100 (1 = 0.01%)") / 100
long_tp = isTP and close > averageLongs + averageLongs / 100 * tp and not longCondition
short_tp = isTP and close < averageShorts - averageShorts / 100 * tp and not shortCondition

/////////////////////////////
//======[ Stop Loss ]======//
/////////////////////////////

isSL = input(true, "Stop Loss")
sl = input(140, "Stop Loss (%). Divided by 100 (1 = 0.01%)") / 100
long_sl = isSL and close < averageLongs - averageLongs / 100 * sl and longCondition == 0
short_sl = isSL and close > averageShorts + averageShorts / 100 * sl and shortCondition == 0

/////////////////////////////////
//======[ Close Signals ]======//
/////////////////////////////////

longClose = long_tp or long_sl or long_ts ? 1 : 0
shortClose = short_tp or short_sl or short_ts ? 1: 0

///////////////////////////////
//======[ Plot Colors ]======//
///////////////////////////////

longCloseCol = na
shortCloseCol = na
longCloseCol := long_tp ? purple : long_sl ? maroon : long_ts ? blue : longCloseCol[1]
shortCloseCol := short_tp ? purple : short_sl ? maroon : short_ts ? blue : shortCloseCol[1]
tpColor = isTP and in_longCondition ? purple : isTP and in_shortCondition ? purple : white
slColor = isSL and in_longCondition ? red : isSL and in_shortCondition ? red : white

//////////////////////////////////
//======[ Strategy Plots ]======//
//////////////////////////////////

plot(isTS and in_longCondition ? averageLongs + averageLongs / 100 * tsi : na, "Long Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_longCondition and last_high >= averageLongs +  averageLongs / 100 * tsi ? last_high - last_high / 100 * ts : na, "Long Trailing", fuchsia, style=2, linewidth=3)
plot(isTS and in_shortCondition ? averageShorts - averageShorts/ 100 * tsi : na, "Short Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_shortCondition and last_low <= averageShorts - averageShorts/ 100 * tsi ? last_low + last_low / 100 * ts : na, "Short Trailing", fuchsia, style=2, linewidth=3)
plot(isTP and in_longCondition and last_high < averageLongs + averageLongs / 100 * tp ? averageLongs + averageLongs / 100 * tp : na, "Long TP", tpColor, style=3, linewidth=2)
plot(isTP and in_shortCondition and last_low > averageShorts - averageShorts / 100 * tp ? averageShorts - averageShorts / 100 * tp : na, "Short TP", tpColor, style=3, linewidth=2)
plot(isSL and in_longCondition and last_low_short > averageLongs - averageLongs / 100 * sl ? averageLongs - averageLongs / 100 * sl : na, "Long SL", slColor, style=3, linewidth=2)
plot(isSL and in_shortCondition and last_high_short < averageShorts + averageShorts / 100 * sl ? averageShorts + averageShorts / 100 * sl : na, "Short SL", slColor, style=3, linewidth=2)

///////////////////////////////
//======[ Alert Plots ]======//
///////////////////////////////

// plot(longCondition, "Long", green)
// plot(shortCondition, "Short", red)
// plot(longClose, "Long Close", longCloseCol)
// plot(shortClose, "Short Close", shortCloseCol)

///////////////////////////////////
//======[ Reset Variables ]======//
///////////////////////////////////

if longClose or not in_longCondition
    averageLongs := 0
    totalLongs := 0.0
    sectionLongs := 0
    sectionLongConditions := 0

if shortClose or not in_shortCondition
    averageShorts := 0
    totalShorts := 0.0
    sectionShorts := 0
    sectionShortConditions := 0

////////////////////////////////////////////
//======[ Strategy Entry and Exits ]======//
////////////////////////////////////////////

if testPeriod()
    strategy.entry("Long", 1, when=longCondition)
    strategy.entry("Short", 0,  when=shortCondition)
    strategy.close("Long", when=longClose)
    strategy.close("Short", when=shortClose)

Lebih lanjut

2019 FMZ - Semua hak dilindungi