RSI double track oscillator strategi perdagangan dua hala panjang dan pendek


Tarikh penciptaan: 2023-10-25 11:57:46 Akhirnya diubah suai: 2023-10-25 11:57:46
Salin: 1 Bilangan klik: 627
avatar of ChaoZhang ChaoZhang
1
fokus pada
1617
Pengikut

RSI double track oscillator strategi perdagangan dua hala panjang dan pendek

Gambaran keseluruhan

Strategi perdagangan dua hala yang menggunakan RSI untuk perdagangan dua hala. Strategi ini menggunakan prinsip RSI untuk membeli dan menjual, menggabungkan pengaturan dua hala dan isyarat perdagangan selaras, untuk membuka dan menutup posisi dua hala yang cekap.

Prinsip Strategi

Strategi ini membuat keputusan perdagangan berdasarkan prinsip overbought dan oversold RSI. Strategi ini terlebih dahulu mengira nilai RSI vrsi, serta sn dan sn sn sn dan ln ln. Apabila RSI turun, ia menghasilkan isyarat plus dan apabila RSI naik, ia menghasilkan isyarat minus.

Strategi ini juga mengesan perubahan naik turun pada baris K dan seterusnya menghasilkan isyarat longLocic apabila baris K menembusi dari bawah ke atas dan shortLogic apabila baris K menembusi dari atas ke bawah. Selain itu, strategi ini menyediakan suis parameter yang boleh digunakan untuk melakukan hanya lebih, hanya kosong, atau membalikkan isyarat.

Selepas menghasilkan banyak isyarat penyingkiran, strategi akan mengkaji jumlah isyarat dan mengawal jumlah pembukaan kedudukan. Peraturan penambahan kedudukan yang berbeza boleh ditetapkan melalui parameter. Syarat penyingkiran termasuk cara berhenti, berhenti, berhenti bergerak, dan banyak lagi. Peratusan berhenti dan berhenti yang berbeza boleh ditetapkan.

Ringkasnya, strategi ini menggunakan pelbagai teknik seperti RSI, persilangan rata-rata, pegangan statistik, dan hentian hentian untuk mencapai perdagangan dua hala secara automatik.

Kelebihan Strategik

  • Menggunakan prinsip RSI untuk membeli dan menjual lebih banyak, anda boleh membuat lebih banyak kedudukan shorting di tempat yang munasabah.
  • Tetapan dua hala untuk mengelakkan isyarat salah. Rel atas menghalang kedudukan berbilang kepala daripada merata terlalu awal, dan rel bawah menghalang kedudukan kosong daripada merata terlalu awal.
  • Sinyal dagangan rata-rata menapis pecah palsu. Harga saham hanya menghasilkan isyarat apabila ia melanggar garis rata-rata, untuk mengelakkan isyarat palsu.
  • Bilangan isyarat statistik dan jumlah penambahan, kawalan risiko.
  • Persentase Stop Loss yang boleh disesuaikan, risiko keuntungan boleh dikawal.
  • Hentikan pergerakan untuk menjejaki hentikan dan teruskan untuk mengunci keuntungan.
  • Ia boleh digunakan untuk melakukan lebih banyak, hanya kosong atau membalikkan isyarat, menyesuaikan diri dengan keadaan pasaran yang berbeza.
  • Sistem perdagangan automatik, mengurangkan kos operasi manual.

Risiko Strategik

  • RSI mempunyai risiko kegagalan untuk berbalik. RSI memasuki zon overbought dan oversold tidak semestinya berbalik.
  • Titik hentian pegangan yang tetap mempunyai risiko untuk disekat. Tetapan hentian pegangan yang tidak betul boleh menyebabkan hentian atau hentian yang terlalu awal.
  • Bergantung kepada petunjuk teknikal, terdapat risiko pengoptimuman parameter. Tetapan parameter penunjuk yang tidak betul akan menjejaskan kesan strategi.
  • Ia boleh menyebabkan pelbagai keadaan berlaku pada masa yang sama, dan ada risiko kehilangan kad.
  • Sistem perdagangan automatik mempunyai risiko kesilapan yang luar biasa.

Untuk menghadapi risiko di atas, anda boleh mengoptimumkan tetapan parameter, menyesuaikan strategi stop loss, meningkatkan penyaringan kecairan, mengoptimumkan logik penjanaan isyarat, meningkatkan pemantauan kesalahan yang luar biasa dan sebagainya.

Arah pengoptimuman strategi

  • Uji parameter RSI untuk mengoptimumkan parameter RSI untuk tempoh yang berbeza.
  • Uji seting peratusan stop loss yang berbeza.
  • Meningkatkan jumlah transaksi atau penyaringan kadar pulangan untuk mengelakkan kekurangan kecairan.
  • Mengoptimumkan logik penjanaan isyarat, memperbaiki cara penyeberangan linear.
  • Menambah pengesanan jangka masa untuk mengesahkan kestabilan.
  • Pertimbangkan untuk menambah indikator lain untuk mengoptimumkan kesan isyarat.
  • Bergabung dengan strategi pengurusan kedudukan.
  • Menambah pemantauan kesalahan yang luar biasa.
  • Mengoptimumkan algoritma pengesanan stop loss automatik.
  • Pertimbangkan untuk menambah strategi pembelajaran mesin.

ringkaskan

Strategi perdagangan dua hala RSI dengan menggunakan pelbagai teknik seperti indikator RSI, asas pembukaan dan hentian statistik, dan lain-lain. Strategi ini mempunyai kebolehsuaian yang kuat, pengguna boleh menyesuaikan parameter mengikut keperluan dan menyesuaikan diri dengan keadaan pasaran yang berbeza.

Kod sumber strategi 
/*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)
Forums
PINE Language FAQ Summary MyLanguage Web3 About Us
Product
Robot Strategy Node Platforms Tickets
API
Syntax guide User guide Trading api Blockchain Indicator

© 2015 - ∞ INVENTOR PTE LTD (SG)