कुबेरन रणनीति: बाजार नियंत्रण के लिए इंटरसेक्शन रणनीति


निर्माण तिथि: 2024-03-22 14:08:11 अंत में संशोधित करें: 2024-03-22 14:08:11
कॉपी: 0 क्लिक्स: 557
1
ध्यान केंद्रित करना
1617
समर्थक

कुबेरन रणनीति: बाजार नियंत्रण के लिए इंटरसेक्शन रणनीति

रणनीति अवलोकन

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

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

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

कुबेरन की रणनीति के मूल में बहु-संकेतक पारस्परिकता का सिद्धांत है। यह एक अद्वितीय सूचक संयोजन का उपयोग करता है जो शोर और गलत संकेतों को कम करने के लिए एक दूसरे के साथ काम करता है। विशेष रूप से, यह रणनीति निम्नलिखित प्रमुख घटकों का उपयोग करती हैः

  1. प्रवृत्ति दिशा का निर्धारणः वर्तमान प्रवृत्ति दिशा का निर्धारण वर्तमान मूल्य की तुलना समर्थन और प्रतिरोध के साथ करें।
  2. समर्थन और प्रतिरोध बिंदुः महत्वपूर्ण समर्थन और प्रतिरोध बिंदुओं को पहचानने के लिए ज़िगज़ैग संकेतकों और केंद्र बिंदुओं के माध्यम से।
  3. विचलन निर्णयः मूल्य आंदोलन और गतिशीलता संकेतकों की तुलना करके, यह निर्णय लें कि क्या विचलन हो रहा है, संभावित प्रवृत्ति को बदलने के लिए संकेत दें।
  4. उतार-चढ़ाव के लिए अनुकूलः एटीआर संकेतक के माध्यम से विभिन्न बाजार उतार-चढ़ाव के लिए स्टॉप को गतिशील रूप से समायोजित करें।
  5. K-लाइन आकृति निर्णयः एक विशेष K-लाइन संयोजन के माध्यम से प्रवृत्ति और रिवर्स सिग्नल की पुष्टि करें।

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

रणनीतिक लाभ

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

रणनीतिक जोखिम

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

उपरोक्त जोखिमों के लिए, उचित नियंत्रण उपायों का उपयोग किया जा सकता है, जैसे कि पैरामीटर को नियमित रूप से समायोजित करना, उचित रोकथाम स्थापित करना, मध्यम नियंत्रण नियंत्रण, मौलिक परिवर्तनों पर ध्यान देना आदि।

अनुकूलन दिशा

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

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2024-03-14 00:00:00
end: 2024-03-21 00:00:00
period: 5m
basePeriod: 1m
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/
// © LonesomeThecolor.blue
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © LonesomeThecolor.blue

//@version=5
strategy('Kuberan*', overlay=true, max_lines_count=500)
lb = input.int(5, title='Left Bars', minval=1)
rb = input.int(5, title='Right Bars', minval=1)
showsupres = input.bool(false, title='Support/Resistance', inline='srcol')
supcol = input.color(color.lime, title='', inline='srcol')
rescol = input.color(color.red, title='', inline='srcol')
// srlinestyle = input(line.style_dotted, title='Line Style/Width', inline='style')
srlinewidth = input.int(3, title='', minval=1, maxval=5, inline='style')
changebarcol = input.bool(true, title='Change Bar Color', inline='bcol')
bcolup = input.color(color.blue, title='', inline='bcol')
bcoldn = input.color(color.black, title='', inline='bcol')

ph = ta.pivothigh(lb, rb)
pl = ta.pivotlow(lb, rb)

iff_1 = pl ? -1 : na  // Trend direction
hl = ph ? 1 : iff_1
iff_2 = pl ? pl : na  // similar to zigzag but may have multTLiple highs/lows
zz = ph ? ph : iff_2
valuewhen_1 = ta.valuewhen(hl, hl, 1)
valuewhen_2 = ta.valuewhen(zz, zz, 1)
zz := pl and hl == -1 and valuewhen_1 == -1 and pl > valuewhen_2 ? na : zz
valuewhen_3 = ta.valuewhen(hl, hl, 1)
valuewhen_4 = ta.valuewhen(zz, zz, 1)
zz := ph and hl == 1 and valuewhen_3 == 1 and ph < valuewhen_4 ? na : zz

valuewhen_5 = ta.valuewhen(hl, hl, 1)
valuewhen_6 = ta.valuewhen(zz, zz, 1)
hl := hl == -1 and valuewhen_5 == 1 and zz > valuewhen_6 ? na : hl
valuewhen_7 = ta.valuewhen(hl, hl, 1)
valuewhen_8 = ta.valuewhen(zz, zz, 1)
hl := hl == 1 and valuewhen_7 == -1 and zz < valuewhen_8 ? na : hl
zz := na(hl) ? na : zz

findprevious() =>  // finds previous three points (b, c, d, e)
    ehl = hl == 1 ? -1 : 1
    loc1 = 0.0
    loc2 = 0.0
    loc3 = 0.0
    loc4 = 0.0
    xx = 0
    for x = 1 to 1000 by 1
        if hl[x] == ehl and not na(zz[x])
            loc1 := zz[x]
            xx := x + 1
            break
    ehl := hl
    for x = xx to 1000 by 1
        if hl[x] == ehl and not na(zz[x])
            loc2 := zz[x]
            xx := x + 1
            break
    ehl := hl == 1 ? -1 : 1
    for x = xx to 1000 by 1
        if hl[x] == ehl and not na(zz[x])
            loc3 := zz[x]
            xx := x + 1
            break
    ehl := hl
    for x = xx to 1000 by 1
        if hl[x] == ehl and not na(zz[x])
            loc4 := zz[x]
            break
    [loc1, loc2, loc3, loc4]

float a = na
float b = na
float c = na
float d = na
float e = na
if not na(hl)
    [loc1, loc2, loc3, loc4] = findprevious()
    a := zz
    b := loc1
    c := loc2
    d := loc3
    e := loc4
    e

_hh = zz and a > b and a > c and c > b and c > d
_ll = zz and a < b and a < c and c < b and c < d
_hl = zz and (a >= c and b > c and b > d and d > c and d > e or a < b and a > c and b < d)
_lh = zz and (a <= c and b < c and b < d and d < c and d < e or a > b and a < c and b > d)

plotshape(_hl, title='Higher Low', style=shape.labelup, color=color.new(color.lime, 0), textcolor=color.new(color.black, 0), location=location.belowbar, offset=-rb)
plotshape(_hh, title='Higher High', style=shape.labeldown, color=color.new(color.lime, 0), textcolor=color.new(color.black, 0), location=location.abovebar, offset=-rb)
plotshape(_ll, title='Lower Low', style=shape.labelup, color=color.new(color.red, 0), textcolor=color.new(color.white, 0), location=location.belowbar, offset=-rb)
plotshape(_lh, title='Lower High', style=shape.labeldown, color=color.new(color.red, 0), textcolor=color.new(color.white, 0), location=location.abovebar, offset=-rb)

float res = na
float sup = na
res := _lh ? zz : res[1]
sup := _hl ? zz : sup[1]

int trend = na
iff_3 = close < sup ? -1 : nz(trend[1])
trend := close > res ? 1 : iff_3

res := trend == 1 and _hh or trend == -1 and _lh ? zz : res
sup := trend == 1 and _hl or trend == -1 and _ll ? zz : sup
rechange = res != res[1]
suchange = sup != sup[1]

var line resline = na
var line supline = na
if showsupres
    if rechange
        line.set_x2(resline, bar_index)
        line.set_extend(resline, extend=extend.none)
        resline := line.new(x1=bar_index - rb, y1=res, x2=bar_index, y2=res, color=rescol, extend=extend.right, style=line.style_dotted, width=srlinewidth)
        resline

    if suchange
        line.set_x2(supline, bar_index)
        line.set_extend(supline, extend=extend.none)
        supline := line.new(x1=bar_index - rb, y1=sup, x2=bar_index, y2=sup, color=supcol, extend=extend.right, style=line.style_dotted, width=srlinewidth)
        supline

iff_4 = trend == 1 ? bcolup : bcoldn
barcolor(color=changebarcol ? iff_4 : na)




// Inputs
A1 = input(5, title='Key Value. \'This changes the sensitivity\' for sell1')
C1 = input(400, title='ATR Period for sell1')
A2 = input(6, title='Key Value. \'This changes the sensitivity\' for buy2')
C2 = input(1, title='ATR Period for buy2')
h = input(false, title='Signals from Heikin Ashi Candles')

xATR1 = ta.atr(C1)
xATR2 = ta.atr(C2)
nLoss1 = A1 * xATR1
nLoss2 = A2 * xATR2

src = h ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close, lookahead=barmerge.lookahead_off) : close

xATRTrailingStop1 = 0.0
iff_5 = src > nz(xATRTrailingStop1[1], 0) ? src - nLoss1 : src + nLoss1
iff_6 = src < nz(xATRTrailingStop1[1], 0) and src[1] < nz(xATRTrailingStop1[1], 0) ? math.min(nz(xATRTrailingStop1[1]), src + nLoss1) : iff_5
xATRTrailingStop1 := src > nz(xATRTrailingStop1[1], 0) and src[1] > nz(xATRTrailingStop1[1], 0) ? math.max(nz(xATRTrailingStop1[1]), src - nLoss1) : iff_6

xATRTrailingStop2 = 0.0
iff_7 = src > nz(xATRTrailingStop2[1], 0) ? src - nLoss2 : src + nLoss2
iff_8 = src < nz(xATRTrailingStop2[1], 0) and src[1] < nz(xATRTrailingStop2[1], 0) ? math.min(nz(xATRTrailingStop2[1]), src + nLoss2) : iff_7
xATRTrailingStop2 := src > nz(xATRTrailingStop2[1], 0) and src[1] > nz(xATRTrailingStop2[1], 0) ? math.max(nz(xATRTrailingStop2[1]), src - nLoss2) : iff_8

pos1 = 0
iff_9 = src[1] > nz(xATRTrailingStop1[1], 0) and src < nz(xATRTrailingStop1[1], 0) ? -1 : nz(pos1[1], 0)
pos1 := src[1] < nz(xATRTrailingStop1[1], 0) and src > nz(xATRTrailingStop1[1], 0) ? 1 : iff_9

pos2 = 0
iff_10 = src[1] > nz(xATRTrailingStop2[1], 0) and src < nz(xATRTrailingStop2[1], 0) ? -1 : nz(pos2[1], 0)
pos2 := src[1] < nz(xATRTrailingStop2[1], 0) and src > nz(xATRTrailingStop2[1], 0) ? 1 : iff_10

xcolor1 = pos1 == -1 ? color.red : pos1 == 1 ? color.green : color.blue
xcolor2 = pos2 == -1 ? color.red : pos2 == 1 ? color.green : color.blue

ema1 = ta.ema(src, 1)
ema2 = ta.ema(src, 1)
above1 = ta.crossover(ema1, xATRTrailingStop1)
below1 = ta.crossover(xATRTrailingStop1, ema1)
above2 = ta.crossover(ema2, xATRTrailingStop2)
below2 = ta.crossover(xATRTrailingStop2, ema2)

buy1 = src > xATRTrailingStop1 and above1
sell1 = src < xATRTrailingStop1 and below1
buy2 = src > xATRTrailingStop2 and above2
sell2 = src < xATRTrailingStop2 and below2

barbuy1 = src > xATRTrailingStop1
barsell1 = src < xATRTrailingStop1
barbuy2 = src > xATRTrailingStop2
barsell2 = src < xATRTrailingStop2

// plotshape(buy1, title="Buy 1", text='Buy 1', style=shape.labelup, location=location.belowbar, color=color.green, textcolor=color.white, transp=0, size=size.tiny)
plotshape(sell1, title='Sell 1', text='Sell 1', style=shape.labeldown, location=location.abovebar, color=color.new(color.red, 0), textcolor=color.new(color.white, 0), size=size.tiny)
plotshape(buy2, title='Buy 2', text='Buy 2', style=shape.labelup, location=location.belowbar, color=color.new(color.green, 0), textcolor=color.new(color.white, 0), size=size.tiny)
// plotshape(sell2, title="Sell 2", text='Sell 2', style=shape.labeldown, location=location.abovebar, color=color.red, textcolor=color.white, transp=0, size=size.tiny)

// barcolor(barbuy1 ? color.green : na)
barcolor(barsell1 ? color.red : na)
barcolor(barbuy2 ? color.green : na)
// barcolor(barsell2 ? color.red : na)

// alertcondition(buy1, "UT Long 1", "UT Long 1")
alertcondition(sell1, 'UT Short 1', 'UT Short 1')
alertcondition(buy2, 'UT Long 2', 'UT Long 2')

// strategy.entry('long', strategy.long, when=buy2)
source = close
length = input.int(20, minval=1)
mult = input.float(2.0, minval=0.001, maxval=50)
basis = ta.sma(source, length)
dev = mult * ta.stdev(source, length)
upper = basis + dev
lower = basis - dev
buyEntry = ta.crossover(source, lower)
sellEntry = ta.crossunder(source, upper)
if (ta.crossover(source, lower) )
	strategy.entry("BBandLE", strategy.long, stop=lower, oca_name="BollingerBands",  comment="BBandLE")
else
	strategy.cancel(id="BBandLE")
if (ta.crossunder(source, upper))
	strategy.entry("BBandSE", strategy.short, stop=upper, oca_name="BollingerBands",comment="BBandSE")
else
	strategy.cancel(id="BBandSE")
//plot(strategy.equity, title="equity", color=color.red, linewidth=2, style=plot.style_areabr)

lengthTL = input.int(14, 'Swing Detection Lookback')
multTL = input.float(1., 'Slope', minval = 0, step = .1)
calcMethod = input.string('Atr', 'Slope Calculation Method', options = ['Atr','Stdev','Linreg'])
backpaint = input(true, tooltip = 'Backpainting offset displayed elements in the past. Disable backpainting to see real time information returned by the indicator.')

//Style
upCss = input.color(color.teal, 'Up Trendline Color', group = 'Style')
dnCss = input.color(color.red, 'Down Trendline Color', group = 'Style')
showExt = input(true, 'Show Extended Lines')

//-----------------------------------------------------------------------------}
//Calculations
//-----------------------------------------------------------------------------{
var upperTL = 0.
var lowerTL = 0.
var slope_phTL = 0.
var slope_plTL = 0.

var offset = backpaint ? lengthTL : 0

n = bar_index
srcTL = close

phTL = ta.pivothigh(lengthTL, lengthTL)
plTL = ta.pivotlow(lengthTL, lengthTL)

//Slope Calculation Method
slope = switch calcMethod
    'Atr'    => ta.atr(lengthTL) / lengthTL * multTL
    'Stdev'  => ta.stdev(srcTL,lengthTL) / lengthTL * multTL
    'Linreg' => math.abs(ta.sma(srcTL * n, lengthTL) - ta.sma(srcTL, lengthTL) * ta.sma(n, lengthTL)) / ta.variance(n, lengthTL) / 2 * multTL

//Get slopes and calculate trendlines
slope_phTL := phTL ? slope : slope_phTL
slope_plTL := plTL ? slope : slope_plTL

upperTL := phTL ? phTL : upperTL - slope_phTL
lowerTL := pl ? pl : lowerTL + slope_plTL

var upos = 0
var dnos = 0
upos := phTL ? 0 : close > upperTL - slope_phTL * lengthTL ? 1 : upos
dnos := pl ? 0 : close < lowerTL + slope_plTL * lengthTL ? 1 : dnos