यह रणनीति शॉर्ट्स और लॉन्ग्स के लिए ओवरबॉट और ओवरसोल्ड स्तर निर्धारित करने के लिए रिलेटिव स्ट्रेंथ इंडेक्स (आरएसआई) संकेतक का उपयोग करती है। यह एक विशिष्ट आरएसआई रिवर्स ट्रेडिंग रणनीति है। रणनीति में विभिन्न बाजार स्थितियों के अनुकूल पैरामीटर अनुकूलन, स्टॉप लॉस आदि भी शामिल हैं।
मूल तर्क में निम्नलिखित शामिल हैंः
आरएसआई संकेतक 70 से ऊपर ओवरबॉट और 30 से नीचे ओवरसोल्ड बाजार स्थितियों को दिखाता है। रणनीति पूर्व निर्धारित सीमाओं के खिलाफ आरएसआई मूल्य के आधार पर लंबी / छोटी प्रविष्टियों को निर्धारित करने के लिए इस क्लासिक तर्क का उपयोग करती है। अनुकूलन योग्य मापदंड बाजार अनुकूलन के लिए सीमाओं, स्टॉप लॉस आदि का अनुकूलन करने की अनुमति देते हैं।
शमन उपाय:
इस रणनीति को निम्न के माध्यम से बढ़ाया जा सकता हैः
ऑटो आरएसआई स्तर अनुकूलन के लिए मशीन लर्निंग
झूठे ब्रेकआउट से बचने के लिए मात्रा की पुष्टि
बहु-कारक पुष्टि के लिए चलती औसत जैसे अतिरिक्त कारक
बाजार की अस्थिरता के आधार पर अनुकूलन रोके
निधियों के प्रवाह/प्रवाहों को मापने के लिए मात्रा विश्लेषण
पोर्टफोलियो के उपयोग को कम करने के लिए गैर-संबद्ध रणनीतियों के साथ संयोजन
यह एक सरल और व्यावहारिक औसत प्रतिगमन रणनीति है जो ओवरबॉट / ओवरसोल्ड का पता लगाने के लिए आरएसआई का उपयोग करती है। अनुकूलन योग्य पैरामीटर बदलते बाजारों के अनुकूलन की अनुमति देते हैं। अनुकूलनशील स्टॉप, बहु-कारक पुष्टि और पैरामीटर अनुकूलन जैसे सुधार रणनीति को अधिक मजबूत बना सकते हैं।
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-18 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("4All V3", shorttitle="Strategy", overlay=true)
/////////////// Component Code Start ///////////////
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(8, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2018, "Backtest Stop Year")
testStopMonth = input(9, "Backtest Stop Month")
testStopDay = input(29, "Backtest Stop Day")
// testStopDay = testStartDay + 1
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
/////////////// Component Code Stop ///////////////
src = close
len = input(4, 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(5)
sn = 100 - rsin
ln = 0 + rsin
/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 10000
tp = input(15, "Take Profit") / 10000
sl = input(23, "Stop Loss") / 10000
pyr = input(1, "Pyramiding")
short = crossover(rsi, sn)
long = crossunder(rsi, ln)
totalLongs = 0
totalLongs := nz(totalLongs[1])
totalShorts = 0
totalShorts := nz(totalShorts[1])
totalLongsPrice = 0
totalLongsPrice := nz(totalLongsPrice[1])
totalShortsPrice = 0
totalShortsPrice := nz(totalShortsPrice[1])
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
longCondition = long and sectionLongs >= pyr
shortCondition = short and sectionShorts >= pyr
last_long = na
last_short = na
last_long := longCondition ? time : nz(last_long[1])
last_short := shortCondition ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = na
last_open_short_signal = na
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = na
last_short_signal = na
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = na
last_low = na
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
long_ts = not na(last_high) and high <= (last_high - ts) //and high >= last_open_long_signal
short_ts = not na(last_low) and low >= (last_low + ts) //and low <= last_open_short_signal
long_tp = high >= (last_open_long_signal + tp)
short_tp = low <= (last_open_short_signal - tp)
long_sl = low <= (last_open_long_signal - sl)
short_sl = high >= (last_open_short_signal + sl)
leverage = input(1, "Leverage")
long_call = last_open_long_signal - (0.8 + 0.2 * (1/leverage)) / leverage * last_open_long_signal
short_call = last_open_short_signal + (0.78 + 0.2 * (1/leverage)) / leverage * last_open_short_signal
long_call_signal = low <= long_call
short_call_signal = high >= short_call
if testPeriod()
strategy.entry("Long", strategy.long, when=longCondition)
strategy.entry("Short", strategy.short, when=shortCondition)
strategy.close("Long", when=long_call_signal)
strategy.close("Short", when=short_call_signal)
strategy.close("Long", when=long_tp)
strategy.close("Short", when=short_tp)
strategy.close("Long", when=long_sl)
strategy.close("Short", when=short_sl)
strategy.close("Long", when=long_ts)
strategy.close("Short", when=short_ts)