1. वर्ग
  2. सर्पिल ब्रेकआउट मूविंग एवरेज रणनीति

सर्पिल ब्रेकआउट मूविंग एवरेज रणनीति

लेखक:चाओझांग, दिनांकः 2024-01-15 11:45:23
टैगः

img

अवलोकन

यह रणनीति सर्पिल चैनल संकेतक और परिवर्तन दर (आरओसी) संकेतक को जोड़ती है। यह खरीद संकेत उत्पन्न करता है जब कीमत ऊपरी बैंड और चलती औसत के माध्यम से टूटती है, और बिक्री संकेत जब कीमत निचले बैंड और चलती औसत के माध्यम से टूटती है। सर्पिल चैनल प्रवृत्ति की दिशा निर्धारित करता है जबकि आरओसी मूल्य गति का पता लगाता है। दोनों संकेतकों के बीच सहमति की आवश्यकता करके, रणनीति का उद्देश्य व्यापार संकेतों की विश्वसनीयता और जीत दर में सुधार करना है।

रणनीति तर्क

यह रणनीति दो प्रमुख संकेतकों पर आधारित हैः

  1. सर्पिल चैनलः प्रवृत्ति की दिशा निर्धारित करने के लिए ऊपरी और निचले बैंड को प्लॉट करें। ऊपरी बैंड से ऊपर की कीमत टूटने से ऊपर की प्रवृत्ति का संकेत मिलता है, जबकि निचले बैंड से नीचे टूटने से नीचे की प्रवृत्ति का संकेत मिलता है।

  2. परिवर्तन दर (ROC): मूल्य त्वरण का पता लगाता है। एक सकारात्मक सीमा से ऊपर ROC तेजी से ऊपर की ओर बढ़ने का संकेत देता है, जबकि नकारात्मक सीमा से नीचे ROC तेजी से नीचे की ओर बढ़ने का संकेत देता है।

खरीद संकेत तब उत्पन्न होते हैं जब स्पिरियल चैनल और आरओसी दोनों ही तेजी के संकेत देते हैं, अर्थात् ऊपरी बैंड से ऊपर की कीमत टूटने के साथ-साथ तेजी से ऊपर की गति होती है। बिक्री संकेत तब शुरू होते हैं जब दोनों संकेतक मंदी की ओर मुड़ते हैं।

संयुक्त संकेत प्रवृत्ति के विरुद्ध व्यापार करने से बचने और विश्वसनीयता में सुधार करने में मदद करते हैं।

लाभ

  1. प्रवृत्ति और गति के बीच समझौते की आवश्यकता के द्वारा उच्च जीत दर के साथ विश्वसनीय संकेत।

  2. पैरामीटर ट्यूनिंग के माध्यम से अनुकूलन योग्य ट्रेडिंग आवृत्ति, उदाहरण के लिए आरओसी पैरामीटर समायोजित करें।

  3. व्यक्तिगत ट्रेडों पर डाउनसाइड जोखिम को सीमित करने के लिए स्टॉप लॉस।

  4. रुझानों को आगे बढ़ाने और लाभप्रदता को और बढ़ाने के लिए तंत्र में पुनः प्रवेश।

जोखिम

  1. संकेत विश्वसनीयता की आवश्यकता के कारण कुछ व्यापारिक अवसरों को खोना और लाभ की संभावना को सीमित करना।

  2. जब रुझान उलट जाता है तो फंसने के लिए असुरक्षित, जिससे संभावित रूप से बड़े नुकसान हो सकते हैं।

  3. खराब पैरामीटर ट्यूनिंग के परिणामस्वरूप बहुत कम या बहुत अधिक संकेत हो सकते हैं।

  4. स्थिर स्टॉप लॉस प्रतिशत भारी प्रतिकूल मूल्य उतार-चढ़ाव पर गंभीर नुकसान को रोकने में असमर्थ।

बढ़ोतरी के अवसर

  1. सर्वोत्तम प्रदर्शन के लिए आरओसी मापदंडों का अनुकूलन करें।

  2. जोखिम और लाभ को संतुलित करने के लिए विभिन्न स्टॉप लॉस स्तरों का परीक्षण करें।

  3. संकेतों को परिष्कृत करने के लिए वॉल्यूम, अस्थिरता संकेतक जैसे अन्य फ़िल्टर जोड़ें।

  4. सर्वोत्तम फिट खोजने के लिए विभिन्न बाजारों में प्रदर्शन का मूल्यांकन करें।

  5. विभिन्न बाजार स्थितियों के लिए गतिशील स्थिति आकार का परिचय।

निष्कर्ष

यह रणनीति ट्रेंड की दिशा और गति का आकलन करने के लिए सर्पिल चैनल और आरओसी को जोड़ती है। इसका उद्देश्य रि-एंट्री और पैरामीटर ट्यूनिंग के माध्यम से लाभप्रदता बनाए रखते हुए सिग्नल विश्वसनीयता है। जोखिम को मुख्य रूप से निश्चित प्रतिशत स्टॉप लॉस द्वारा नियंत्रित किया जाता है। कुल मिलाकर यह एक अपेक्षाकृत पूर्ण ढांचा है जो बेसलाइन मात्रात्मक ट्रेडिंग रणनीति के योग्य है।

/*backtest
start: 2024-01-07 00:00:00
end: 2024-01-14 00:00:00
period: 45m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("SSL Chaikin BF 🚀", overlay=true, precision=2, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)

/////////////// Time Frame ///////////////
_0 = input(false,  "════════ Test Period ═══════")
testStartYear = input(2017, "Backtest Start Year") 
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)

testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true

/////////////// Chaikin MF /////////////// 
_1 = input(false,  "═══════ Chaikin MF ═══════")
length = input(20, minval=1, title = "Chaikin SMA Length")
upperThreshold = input(0.04, step=0.01, title="Upper Threshold")
lowerThreshold = input(0.02, step=0.01, title="Lower Threshold")
ad = close==high and close==low or high==low ? 0 : ((2*close-low-high)/(high-low))*volume
mf = sum(ad, length) / sum(volume, length)

/////////////// SSL Channels /////////////// 
_2 = input(false,  "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)

smaHigh = sma(high, len1)
smaLow = sma(low, len2)

Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh

///////////// Rate Of Change ///////////// 
_3 = input(false,  "══════ Rate of Change ══════")
source = close
roclength = input(13, "ROC Length",  minval=1)
pcntChange = input(4, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))

///////////////  Strategy  /////////////// 
long = sslUp > sslDown and isMoving() or crossover(mf, upperThreshold)
short = sslUp < sslDown and isMoving() or crossunder(mf, lowerThreshold)

last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])

long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

last_open_long_signal = 0.0
last_open_short_signal = 0.0
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 = 0.0
last_short_signal = 0.0
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 = 0.0
last_low = 0.0
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])

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1]) 
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) 

//////////////// Stop loss /////////////// 
_4 = input(false,  "════════ Stop Loss ═══════")
sl_inp = input(2.0, title='Stop Loss %') / 100

slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na

/////////////// Execution /////////////// 
if testPeriod()
    strategy.entry("L", strategy.long, when=long)
    strategy.entry("S", strategy.short, when=short)
    strategy.exit("L SL", "L", stop=long_sl, when=since_longEntry > 0)
    strategy.exit("S SL", "S", stop=short_sl, when=since_shortEntry > 0)

/////////////// Plotting /////////////// 
p1 = plot(sslDown, linewidth = 1, color=color.red)
p2 = plot(sslUp, linewidth = 1, color=color.lime)
fill(p1, p2,  color = sslDown < sslUp ? color.lime : color.red, transp=80)
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
bgcolor(crossover(mf, upperThreshold) ? color.blue : crossunder(mf, lowerThreshold) ? color.orange : na, transp=30)
अधिक

2019 FMZ - सभी अधिकार सुरक्षित