बोलिंगर बैंड गति फटने की रणनीति

लेखक:चाओझांग, दिनांकः 2023-10-31 15:54:41
टैगः

img

अवलोकन

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

सिद्धांत

इस रणनीति में निम्नलिखित मुख्य भाग शामिल हैंः

  1. बोलिंगर बैंड्स सेटिंग्सः लंबाई 40 के साथ बड़े बैंड, लंबाई 20 के साथ छोटे बैंड, बैंड चौड़ाई 2 मानक विचलन है।

  2. बैंड विस्फोट निर्णयः यदि बड़ा बैंड ऊपरी छोटे बैंड ऊपरी से नीचे है, और बड़ा बैंड निचला छोटे बैंड निचले से ऊपर है, तो यह बढ़ी हुई अस्थिरता का संकेत देता है और नए रुझान दिशा संकेत उत्पन्न करता है।

  3. गति संकेतकः 240 समय सीमा 14 ईएमए प्रवृत्ति की दिशा का आकलन करता है।

  4. एटीआर स्टॉप लॉस और ले लाभः स्टॉप लॉस दूरी के लिए एटीआर 14 गुना, ले लाभ स्टॉप लॉस दूरी का 1.5 गुना है।

रणनीति पहले यह तय करती है कि बैंड फट जाएगा या नहीं, फिर गति की दिशा के आधार पर लंबा या छोटा निर्धारित करती है। प्रवेश के बाद, स्टॉप लॉस के लिए एटीआर गुणकों का उपयोग करें और लाभ प्रबंधन लें।

लाभ

  1. डबल बोलिंगर बैंड का उपयोग करके ट्रेंड फटने के बिंदुओं को निर्धारित करने के लिए समय सीमाओं में अस्थिरता की तुलना की जा सकती है।

  2. गति संकेतक का उपयोग करने से बाजारों के बीच की सीमाओं से प्रभावित होने से बचा जा सकता है।

  3. एटीआर स्टॉप बाजार की अस्थिरता के आधार पर स्टॉप दूरी को समायोजित करता है।

  4. उचित जोखिम प्रतिफल अनुपात, बहुत आक्रामक या रूढ़िवादी नहीं।

जोखिम

  1. स्पष्ट रुझानों के बिना बाजारों में फंस सकता है। झूठे संकेतों को कम करने के लिए गति मापदंडों को अनुकूलित कर सकता है।

  2. एटीआर स्टॉप बहुत रूढ़िवादी हो सकते हैं। अन्य स्टॉप विधियों पर विचार करें जैसे कि ट्रेलिंग स्टॉप।

  3. निश्चित एटीआर गुणक सभी उत्पादों के लिए उपयुक्त नहीं हो सकता है। इसे समायोज्य बनाने पर विचार करें।

  4. दोहरी बोलिंगर प्रभावशीलता अप्रमाणित है. केडी जैसे अन्य चैनलों का परीक्षण करें.

अनुकूलन दिशाएँ

  1. इष्टतम संयोजन खोजने के लिए विभिन्न गति मापदंडों का परीक्षण करें।

  2. अलग-अलग स्टॉप विधियों की कोशिश करें जैसे ट्रेसिंग स्टॉप, अनुकूलन एटीआर।

  3. एटीआर गुणकों को उत्पाद और बाजार की स्थितियों के आधार पर समायोज्य बनाएं।

  4. अधिक स्थिरता के लिए विभिन्न चैनल संकेतकों का परीक्षण करें।

  5. बेहतर लाभ नियंत्रण के लिए मिश्रण प्रबंधन जोड़ने पर विचार करें।

  6. जीत दर में सुधार के लिए स्विंग, समय आदि द्वारा प्रवेश संकेतों को फ़िल्टर करें।

निष्कर्ष

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


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

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © kasaism
//@version=4
// strategy(title="[EURUSD60] BB Expansion Strategy", shorttitle="[EURUSD60] BBEXP",overlay=true, max_bars_back=5000, max_labels_count=500)

// === INPUTS === //
////BB
largeBbRes = input(title="Large BB Resolution", type=input.resolution, defval="", group="BB")
largeBbLength = input(title="Large BB Length", type=input.integer, defval=40, minval=1, group="BB")
smallBbRes = input(title="Small BB Resolution ", type=input.resolution, defval="", group="BB")
smallBbLength = input(title="Small BB Length", type=input.integer, defval=20, minval=1, group="BB")
multi = input(title="BB StdDev", type=input.float, defval=2.0, maxval=10, minval=0.01, group="BB")
validLen = input(title="BB expand valid length", defval=14, group="BB")

// 3 each EMA settings. EMA directions are as each time frame directions. 
resFirstTime = input(title="EMA Trend t/f", type=input.resolution, defval="240", group="SMT")
// resSecondTime = input(title="Second t/f", type=input.resolution, defval="30", group="SMT") 
// resThirdTime = input(title="Third t/f", type=input.resolution, defval="", group="SMT")
emaLen = input(14, minval=1, title="Length", group="SMT") 
smooth = input(3, minval=1, title="Smooth factor", group="SMT")

//Lisk Management
var riskManagementRule1 = "ATR"
var riskManagementRule2 = "Bracket"
riskManagementRule = input(riskManagementRule1, "Detect Risk Management Based On", options=[riskManagementRule1, riskManagementRule2, "No detection"], group="Trade")
atrMulti = input(3.0, title="ATR Multiple", type=input.float, minval = 1.0, group="ATR")
riskRewardRatio = input(1.5, title="Risk Reward Ratio for ATR", type=input.float, minval = 0.01, group="ATR")
stopLossPoint = input(100, title="Stop Loss Point for Braket(tick)", type=input.float, minval = 1.0, group="Bracket")
takeProfitPoint = input(200, title="Take Profit Point for Braket(tick)", type=input.float, minval = 1.0, group="Bracket")
// === /INPUTS/ === //

// === CONSTANT === //
//For barmerge.lookahead_off
index = barstate.isrealtime ? 1 : 0

//For Entry
NOENTRY=0
LONG=1
SHORT=2

//SMT color
int up=1
int dn=2
int up_HL=3
int dn_HL=4

//label color
color_bearish = color.red
color_bullish = color.blue
C_label_color_bearish = color.red
C_label_color_bullish = color.blue
// === /CONSTANT/ === //


// === FUNCTIONS === //
//BB trade direction
bbTradeDetection(lrgUpper, lrgLower, smlUpper, smlLower) =>
    if not(na(lrgUpper) or na(lrgLower) or na(smlUpper) or na(smlLower))
        if lrgUpper < smlUpper and lrgLower > smlLower
            true
        else
            false
    else
        na
// === /FUNCTIONS/ === //


// === CALCURATES === //
////BB
//large BB
lrgBbBasis = security(syminfo.tickerid, largeBbRes, sma(close[index], largeBbLength))
lrgBbDev = multi * security(syminfo.tickerid, largeBbRes, stdev(close[index], largeBbLength))
lrgBbUpper = lrgBbBasis + lrgBbDev
lrgBbLower = lrgBbBasis - lrgBbDev

//small BB
smlBbBasis = security(syminfo.tickerid, smallBbRes, sma(close[index], smallBbLength))
smlBbDev = multi * security(syminfo.tickerid, smallBbRes, stdev(close[index], smallBbLength))
smlBbUpper = smlBbBasis + smlBbDev
smlBbLower = smlBbBasis - smlBbDev

bbTrade = bbTradeDetection(lrgBbUpper, lrgBbLower, smlBbUpper, smlBbLower)

//EMA Trend
base=security(syminfo.tickerid, resFirstTime, ema(close[index],emaLen))
sig=security(syminfo.tickerid, resFirstTime, ema(base[index],smooth))
emaTrend = not(na(base) or na(sig)) ? base < sig ? dn : up : na

////LISK MANAGEMENT
float stopLossLineForLong = na
float stopLossLineForShort = na
float takeProfitLineForLong = na
float takeProfitLineForShort = na
atr_ = atr(14) * atrMulti

if riskManagementRule == riskManagementRule1
    stopLossLineForLong := strategy.position_size > 0 ? stopLossLineForLong[1] ? stopLossLineForLong[1] : round(close[index] - atr_,3) : na
    stopLossLineForShort := strategy.position_size < 0 ? stopLossLineForShort[1] ? stopLossLineForShort[1] : round(close[index] + atr_,3) : na
    takeProfitLineForLong := strategy.position_size > 0 ? takeProfitLineForLong[1] ? takeProfitLineForLong[1] : close[index] + atr_*riskRewardRatio : na
    takeProfitLineForShort := strategy.position_size < 0 ? takeProfitLineForShort[1] ? takeProfitLineForShort[1] :close[index] - atr_*riskRewardRatio : na

if riskManagementRule == riskManagementRule2
    stopLossLineForLong := strategy.position_size > 0 ? stopLossLineForLong[1] ? stopLossLineForLong[1] : close[index] - stopLossPoint * syminfo.mintick : na
    stopLossLineForShort := strategy.position_size < 0 ? stopLossLineForShort[1] ? stopLossLineForShort[1] : close[index] + stopLossPoint * syminfo.mintick : na
    takeProfitLineForLong := strategy.position_size > 0 ? takeProfitLineForLong[1] ? takeProfitLineForLong[1] : close[index] +takeProfitPoint * syminfo.mintick : na
    takeProfitLineForShort := strategy.position_size < 0 ? takeProfitLineForShort[1] ? takeProfitLineForShort[1] :close[index] - takeProfitPoint * syminfo.mintick : na
// === /CALCURATES/ === //


// === CONDITIONS === //
//BB
bool isBbEntry = na
for i=0 to validLen
    isBbEntry := bbTrade==true ? true : bbTrade[i]==true ? true : false
//plotshape(isBbEntry, style=shape.circle, location=location.bottom)

isBbLong = isBbEntry and open[index] < smlBbBasis[index] and close[index] > smlBbBasis[index]
isBbShort = isBbEntry and open[index] > smlBbBasis[index] and close[index] < smlBbBasis[index]  

//SMT
isEmaLong = emaTrend == up 
isEmaShort = emaTrend == dn

//ATR
isAtrLongStop = low[index] <= stopLossLineForLong
isAtrShortStop = high[index] >= stopLossLineForShort
isAtrLongLimit = high[index] >= takeProfitLineForLong
isAtrShortLimit = low[index] <= takeProfitLineForShort
// === /CONDITIONS/ === //


// === TRADE === //
//ENTRY
if (isBbLong and isEmaLong)
    strategy.entry("LongEntry", strategy.long,  comment="LongEntry")
    if riskManagementRule == riskManagementRule2
        strategy.exit("LongEntry", loss=stopLossPoint, profit=takeProfitPoint, comment="bracket")
if (isBbShort and isEmaShort)
    strategy.entry("ShortEntry", strategy.short,  comment="ShortEntry")
    if riskManagementRule == riskManagementRule2	        
        strategy.exit("ShortEntry", loss=stopLossPoint, profit=takeProfitPoint, comment="bracket")
//EXIT
if riskManagementRule == riskManagementRule1
    if(isAtrLongStop)
        strategy.close("LongEntry", when=isAtrLongStop, comment="ATR Stop")
    if(isAtrShortStop)
        strategy.close("ShortEntry", when=isAtrShortStop, comment="ATR Stop")
    if(isAtrLongLimit)
        strategy.close("LongEntry", when=isAtrLongLimit, comment="ATR Limit")
    if(isAtrShortLimit)
        strategy.close("ShortEntry", when=isAtrShortLimit, comment="ATR Limit")
//  === /TRADE/ === //


// === PLOTS === //
plot(lrgBbBasis, title="Large BB Basis", linewidth=2, color=color.gray)
plot(lrgBbUpper, title="Large BB Upper", linewidth=2, color=color.gray)
plot(lrgBbLower, title="Large BB Lower", linewidth=2, color=color.gray)
plot(smlBbBasis, title="Small BB Basis", color=color.white)
plot(smlBbUpper, title="Small BB Upper", color=color.white)
plot(smlBbLower, title="Small BB Lower", color=color.white)
plot(base, title="EMA Line", color= emaTrend==dn ? color_bearish : emaTrend==up ? color_bullish : color.gray)

plot(stopLossLineForLong ? stopLossLineForLong : na, title="S/L Line For Long", color=color.yellow, style=plot.style_circles)
plot(stopLossLineForShort ? stopLossLineForShort : na, title="S/L Line For Short", color=color.yellow, style=plot.style_circles)
plot(takeProfitLineForLong ? takeProfitLineForLong : na, title="T/P Line For Long", color=color.purple, style=plot.style_circles)
plot(takeProfitLineForShort ? takeProfitLineForShort : na, title="T/P Line For Short", color=color.purple, style=plot.style_circles)
// /=== PLOTS ===/ //

अधिक