RSI-Doppelspur-Oszillator – Long- und Short-Zweiwege-Handelsstrategie

Erstellungsdatum: 2023-10-25 11:57:46 zuletzt geändert: 2023-10-25 11:57:46

Kopie: 1 Klicks: 627

ChaoZhang

konzentrieren Sie sich auf Private Nachricht

konzentrieren Sie sich auf

1617

Anhänger

RSI-Doppelspur-Oszillator – Long- und Short-Zweiwege-Handelsstrategie

Überblick

Die RSI-Doppelbahnen-Schwingungslinie ist eine Strategie, bei der der RSI-Indikator verwendet wird, um in zwei Richtungen zu handeln. Die Strategie kombiniert die Doppelbahnen-Einstellungen und die Einheitslinie-Handelssignale, um eine effiziente Doppelbahnen-Eröffnung und -Begrenzung durch den RSI-Indikator zu erreichen.

Strategieprinzip

Die Strategie basiert hauptsächlich auf dem Überkauf-Überverkauf-Prinzip des RSI. Die Strategie berechnet zunächst den Wert des RSI, der Vrsi, sowie den Auf- und Unterkurs Sn und Ln in der doppelten Bahn. Es wird ein Mehrwertsignal erzeugt, wenn der RSI unter dem Wert liegt und ein Leerwertsignal erzeugt wird, wenn der RSI über dem Wert liegt.

Die Strategie erkennt auch die Veränderung der K-Linien und erzeugt weitere Mehr-Logik-Signale. Insbesondere wird ein Mehr-Logik-Signal langLocic erzeugt, wenn die K-Line von unten nach oben durchbricht, und ein ShortLogic, wenn die K-Line von oben nach unten durchbricht. Darüber hinaus bietet die Strategie einen Parameterschalter, der nur mehr, nur Leer oder umgedreht werden kann.

Nach der Erzeugung von mehreren Leerlaufsignalen wird die Strategie die Anzahl der Signale berechnet und die Anzahl der Positionen kontrolliert. Durch die Parameter können verschiedene Aufnahme-Regeln eingestellt werden. Die Leerlaufbedingungen umfassen Stop-Loss, Stop-Loss, Moving Stop-Loss usw.

Die Strategie kombiniert verschiedene Techniken wie RSI-Indikatoren, Durchschnittskreuzungen, statistische Verlagerungen und Stop-Loss-Stopps, um einen automatischen langen und kurzen Zwei-Wege-Handel zu ermöglichen.

Strategische Vorteile

Es ist möglich, dass die RSI-Indikator überkauft und überverkauft wird, um mehr Depositionen in vernünftigen Positionen aufzubauen.
Doppelbahn-Einstellungen vermeiden Fehlsignale. Oberbahn verhindert vorzeitige Platzierung von mehrköpfigen Positionen und Unterbahn verhindert vorzeitige Platzierung von leeren Positionen.
Der Kurs der Aktie wird nur durch den Durchschnittskurs gefiltert, um falsche Signale zu vermeiden.
Anzahl der Signal- und Aufschlag-Statistiken, Risikokontrolle.
Anpassbare Stop-Loss-Prozentsätze und ein kontrollierbares Gewinn-Risiko.
Mobile Stop-Losses verfolgen Stop-Losses, um die Gewinne weiter zu sperren.
Es ist möglich, nur mehr zu tun, nur zu leeren oder umzudrehen, um sich an unterschiedliche Marktbedingungen anzupassen.
Automatisierte Handelssysteme, um die Kosten für die Handhabung zu senken.

Strategisches Risiko

Der RSI-Indikator ist in Gefahr, sich umzukehren. Wenn der RSI in eine überkaufte und überverkaufte Zone eintritt, muss er sich nicht umkehren.
Ein Fixed Stop-Loss-Punkt ist gefährdet. Eine falsche Einstellung des Stop-Loss-Punktes kann zu einem vorzeitigen Stop-Loss oder einer vorzeitigen Stopps führen.
Abhängigkeit von technischen Indikatoren, Risiken bei der Optimierung von Parametern. Fehlende Einstellung von Indikatorparametern beeinträchtigt die Effektivität der Strategie.
Es ist möglich, dass mehrere Bedingungen gleichzeitig ausgelöst werden, wodurch die Gefahr besteht, dass die Karten ausgelassen werden.
Es besteht die Gefahr, dass automatische Handelssysteme abnormale Fehler machen.

Um diese Risiken anzugehen, können die Parameter-Einstellungen optimiert, die Stop-Loss-Strategie angepasst, die Liquiditätsfilterung erhöht, die Signalgenerationslogik optimiert und die Ausnahmefehlerüberwachung erhöht werden.

Richtung der Strategieoptimierung

Testen Sie die RSI-Indikatorparameter für die Optimierung von Parametern für verschiedene Perioden.
Verschiedene Stop Loss Prozentsatz-Einstellungen testen.
Erhöhung des Handelsvolumens oder der Ertragsrate, um eine unzureichende Liquidität zu vermeiden.
Optimierung der Signalgenerationslogik und Verbesserung der Durchschnittslinie.
Mehrfach zu überprüfen, um die Stabilität zu überprüfen.
Erwägen Sie, weitere Kennzahlen hinzuzufügen, um die Signalwirkung zu optimieren.
Eintritt in die Strategie zur Positionsverwaltung.
Erhöhung der Überwachung von Ausnahmefehlern.
Optimierung der automatischen Stop-Loss-Tracking-Algorithmen
Erwägen Sie die Einbeziehung von Strategien zur Verbesserung des maschinellen Lernens.

Zusammenfassen

Die RSI-Strategie bietet eine hohe Anpassbarkeit, so dass Benutzer ihre Parameter an die jeweiligen Bedürfnisse anpassen können. Die Strategie bietet außerdem ein gewisses Maß an Optimierungsmöglichkeiten, wie zum Beispiel die Einstellung der Parameter, die Strategie zur Windkontrolle und die Logik der Signalgenerierung, um die Strategie stabiler und zuverlässiger zu machen. Insgesamt bietet die Strategie Benutzern eine relativ leistungsfähige Handelsstrategie.

Strategiequellcode

/*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