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


निर्माण तिथि: 2024-01-24 11:05:56 अंत में संशोधित करें: 2024-01-24 11:05:56
कॉपी: 0 क्लिक्स: 949
1
ध्यान केंद्रित करना
1617
समर्थक

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

अवलोकन

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

रणनीति सिद्धांत

इस रणनीति का उपयोग ब्रिन बेल्ट के ऊपर और नीचे के रेल के रूप में किया जाता है। यह एक अवसर क्षेत्र है। विशेष रूप से, जब कीमत नीचे की रेल से कम होती है, तो कई स्टॉक खोले जाते हैं; जब कीमत ऊपर की रेल से अधिक होती है, तो एक खाली स्टॉक खोला जाता है।

इसके अलावा, यह रणनीति चलती औसत का उपयोग निष्क्रिय स्थिति के लिए एक बेंचमार्क के रूप में करती है। जब आप कई ऑर्डर रखते हैं, तो आप निष्क्रिय स्थिति का चयन करते हैं यदि कीमत चलती औसत से अधिक है; इसी तरह, जब आप खाली ऑर्डर रखते हैं, तो आप निष्क्रिय स्थिति का चयन करते हैं यदि कीमत चलती औसत से कम है।

रुकावट के लिए, यह रणनीति प्रवेश मूल्य के एक निश्चित प्रतिशत के साथ इस सरल रोलिंग रुकावट का उपयोग करती है। यह एकतरफा परिस्थितियों में भारी नुकसान से बचने के लिए प्रभावी है।

श्रेष्ठता विश्लेषण

इस रणनीति के कुछ प्रमुख लाभ हैंः

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

जोखिम विश्लेषण

इस रणनीति के कुछ जोखिम भी हैं:

  1. ब्रिन बेल्ट हमेशा एक विश्वसनीय प्रवेश सूचक नहीं होता है और कभी-कभी यह गलत संकेत देता है।
  2. बाजार की रणनीतियों को अस्थिरता में कैद किया जा सकता है।
  3. यदि आप किसी भी तरह की समस्या का सामना करना चाहते हैं, तो यह आपके लिए बहुत आसान हो सकता है।

इन जोखिमों को कम करने के लिए, हम अन्य संकेतकों के साथ मिलकर फ़िल्टरिंग पर विचार कर सकते हैं, स्टॉप-लॉस रणनीति को अनुकूलित कर सकते हैं, या स्थिति के आकार को उचित रूप से सीमित कर सकते हैं।

अनुकूलन दिशा

इस रणनीति को और भी बेहतर बनाने के लिए जगह हैः

  1. विभिन्न मापदंडों के संयोजनों का परीक्षण करके इष्टतम मापदंडों का पता लगाया जा सकता है।
  2. मल्टी फैक्टर वेरिफिकेशन के लिए अधिक फ़िल्टरिंग मापदंडों को जोड़ा जा सकता है।
  3. मशीन सीखने के तरीकों का उपयोग करके पैरामीटर को स्वचालित रूप से अनुकूलित किया जा सकता है
  4. अधिक परिष्कृत रोकथाम का उपयोग करने पर विचार किया जा सकता है, जैसे कि पैरालाइट रोकथाम।

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2023-12-24 00:00:00
end: 2024-01-23 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy(shorttitle="BBL", title="BB limit", overlay = true)


length = input(200, minval=1)
src = input(hlc3, title="Source")
xmult = input(44, minval=0.001, maxval=5000, title = "bb mult (0.1%)")
s = input(title="Trend source", defval = "sma", options = ["ema", "sma", "rma", "wma"])
basis = s == "ema" ? ema(src, length) : s == "sma" ? sma(src, length) : s =="rma" ? rma(src, length) : wma(src, length)
sd = input(title="Dev source", defval = "stdev", options = ["stdev", "dev"])
mult = xmult / 10  
dev = sd == "stdev" ? mult * stdev(src, length) : mult * dev(src, length)
diff = input(0.5, title = "Spread")
LongPrice(p) =>
    LongPrice = diff == 0 ? p : floor(p / diff) * diff

ShortPrice(p) =>
    ShortPrice = diff == 0 ? p : ceil(p / diff) * diff

pyr = input(1, title = "Pyramiding")
useStopLoss = input(true)
stoploss_xmult = input(15, minval=0.001, maxval=5000, title = "StopLoss 0.1%")
stopLoss_mult = sd == "simple" ? 1 + stoploss_xmult / 10 / 100 : stoploss_xmult / 10  
dev2 = sd == "stdev" ? stopLoss_mult * stdev(src, length) : sd == "dev" ? stopLoss_mult * dev(src, length) : (stopLoss_mult - 1) * basis
upper = basis + (1*dev)
lower = basis - (1*dev)
plot(basis, color=fuchsia, linewidth=2)
plot(upper, color=green, linewidth=2)
plot(lower, color=green, linewidth=2)


strategy.cancel_all()

if strategy.position_size > 0 and close <= basis + diff * 2
    strategy.order("Close long", strategy.short, strategy.position_size, limit = ShortPrice(basis))
else 
    if strategy.position_size < 0 and close >= basis - diff * 2
        strategy.order("Close short", strategy.long, -strategy.position_size, limit = LongPrice(basis))
            
stopLossPrice1 = na
stopLossPrice2 = na
add = na
openOrderCondition = close > lower - 2 * diff and (strategy.opentrades < pyr or (strategy.position_size < 0 and strategy.position_avg_price > lower * (1 + stopLoss_mult / 100)))
if openOrderCondition
    add := strategy.position_size > 0 ? -strategy.position_size : close >= basis - diff * 2 ? 0 : -strategy.position_size
    strategy.order("Open long", strategy.long, strategy.equity / pyr / lower + add, limit = LongPrice(lower))
if useStopLoss and (strategy.position_size > 0 or openOrderCondition)
    add = openOrderCondition ? strategy.equity / pyr / lower : 0
    posPrice = strategy.position_size <= 0 ? lower : strategy.position_avg_price
    posSize = strategy.position_size <= 0 ? 0 : strategy.position_size
    stopLossPrice1 := posPrice * (1 - stopLoss_mult / 100)
    strategy.order("StopLoss open short ", strategy.short, posSize + add + strategy.equity / pyr / stopLossPrice1, stop = ShortPrice(stopLossPrice1))


openOrderCondition := close < upper + 2 * diff and (strategy.opentrades < pyr or (strategy.position_size > 0 and strategy.position_avg_price * (1 + stopLoss_mult / 100) < upper))
if openOrderCondition
    add := strategy.position_size < 0 ? strategy.position_size : close <= basis + diff * 2 ? 0 : strategy.position_size
    strategy.order("Open short", strategy.short, strategy.equity / pyr / upper + add, limit = ShortPrice(upper))
if useStopLoss and (strategy.position_size < 0 or openOrderCondition)
    add = openOrderCondition ? strategy.equity / pyr / upper : 0
    posPrice = strategy.position_size >= 0 ? upper : strategy.position_avg_price
    posSize = strategy.position_size >= 0 ? 0 : -strategy.position_size
    stopLossPrice2 := posPrice * (1 + stopLoss_mult / 100)
    strategy.order("StopLoss open long", strategy.long, posSize + add + strategy.equity / pyr / stopLossPrice2, stop = LongPrice(stopLossPrice2))

plot(not useStopLoss ? na : stopLossPrice1, color=red, linewidth=2)
plot(not useStopLoss ? na : stopLossPrice2, color=red, linewidth=2)

// === Backtesting Dates ===
testPeriodSwitch = input(false, "Custom Backtesting Dates")
testStartYear = input(2018, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testStartHour = input(0, "Backtest Start Hour")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,testStartHour,0)
testStopYear = input(2018, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(14, "Backtest Stop Day")
testStopHour = input(14, "Backtest Stop Hour")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,testStopHour,0)
testPeriod() =>
    time >= testPeriodStart and time <= testPeriodStop ? true : false
isPeriod = testPeriodSwitch == true ? testPeriod() : true
// === /END
if not isPeriod
    strategy.cancel_all()
    strategy.close_all()