गति ABCD पैटर्न रणनीति

लेखक:चाओझांग, दिनांक: 2023-09-24 13:08:28
टैगः

अवलोकन

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

रणनीति तर्क

  1. मूल्य शिखर और तटीय स्तरों की पहचान करने के लिए विलियम्स फ्रैक्टल संकेतक का उपयोग करें। तेजी या गिरावट एबीसीडी पैटर्न निर्धारित करने के लिए विभिन्न पैटर्न का उपयोग किया जाता है।

  2. एबीसीडी पैटर्न पहचान मानदंडः

    • एबी और सीडी के बीच की दूरी समान है, और बीसी और सीडी के बीच की दूरी कुछ आनुपातिक आवश्यकताओं को पूरा करती है (0.382-0.886 और 1.13-2.618 के बीच) ।

    • D बिंदु C बिंदु से नीचे एक तेजी का पैटर्न है। D बिंदु C बिंदु से ऊपर एक मंदी का पैटर्न है।

  3. समग्र रुझान की दिशा का न्याय करने के लिए कौन सी दिशा s फ्रैक्टल वर्तमान के करीब है, यह निर्धारित करने के लिए बारसेंट फ़ंक्शन का उपयोग करें।

  4. एबीसीडी पैटर्न की पहचान करने के बाद लॉन्ग/शॉर्ट दर्ज करें, और मध्यम अवधि के रुझानों का पालन करने के लिए स्टॉप लॉस और ले लाभ सेट करें।

लाभ विश्लेषण

  1. विलियम्स फ्रैक्टल सूचक अधिक सटीक रूप से मोड़ बिंदुओं की पहचान करने में मदद करता है।

  2. एबीसीडी पैटर्न मानदंड सरल और विश्वसनीय है, स्वचालित करने में आसान है।

  3. मुख्य रुझान की दिशा को बारसिंथ से आंकना झूठे ब्रेकआउट से होने वाले नुकसान से बचाता है।

  4. स्टॉप लॉस के साथ रुझानों का अनुसरण करना और प्रवेश के बाद लाभ लेना।

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

  1. विलियम्स फ्रैक्टल में देरी हो सकती है और नुकसान का कारण बनने वाले मोड़ को याद कर सकता है।

  2. कई ओवरलैपिंग एबीसीडी पैटर्न मध्यम अवधि के चार्ट पर गलत पहचान का कारण बन सकते हैं।

  3. गलत प्रमुख रुझान दिशा मध्यम अवधि के ट्रेडों में फंसने का जोखिम बढ़ाती है।

  4. बहुत तंग स्टॉप लॉस आसानी से बंद हो सकता है। बहुत चौड़ा स्टॉप लॉस खराब ट्रैकिंग का कारण बन सकता है।

संभावित समाधान:

  1. मोड़ के बिंदुओं को अधिक प्रभावी ढंग से पहचानने में सहायता के लिए अन्य संकेतकों का परीक्षण करें।

  2. पहचान को अधिक सख्त और विश्वसनीय बनाने के लिए एबीसीडी पैटर्न मापदंडों को अनुकूलित करें।

  3. गलत दिशात्मक पूर्वाग्रह से बचने के लिए प्रमुख प्रवृत्ति की पहचान में सुधार।

  4. इष्टतम बिंदुओं को खोजने के लिए विभिन्न स्टॉप लॉस/टेक प्रॉफिट अनुपातों का परीक्षण करें।

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

  1. प्रवेश संकेतों की सटीकता में सुधार के लिए एमएसीडी, केडीजे और अन्य संकेतकों का परीक्षण करें।

  2. स्टॉप लॉस/टेक प्रॉफिट के इष्टतम स्तरों को खोजने के लिए विभिन्न उत्पादों और समय सीमाओं के आधार पर मापदंडों का अनुकूलन करें।

  3. बाजार की बदलती स्थितियों के अनुसार सर्वोत्तम पैरामीटर संयोजन खोजने के लिए बार लुकबैक अवधि का अनुकूलन करें।

  4. संकेतों को फ़िल्टर करने और स्थिरता में सुधार करने के लिए चलती औसत आदि जोड़ें।

  5. पैटर्न पहचान की सटीकता में सुधार के लिए मशीन लर्निंग एल्गोरिदम और अधिक डेटा पेश करें।

सारांश

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


/*backtest
start: 2023-09-16 00:00:00
end: 2023-09-23 00:00:00
period: 45m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// @version=4
// @author=Daveatt - BEST

// ABCD Pattern Strat

StrategyName        = "BEST ABCD Pattern Strategy"
ShortStrategyName   = "BEST ABCD Pattern Strategy" 

// strategy(title=StrategyName, shorttitle=ShortStrategyName, overlay=true, 
//  pyramiding=2, default_qty_value=100, precision=7, currency=currency.USD,
//  commission_value=0.2,commission_type=strategy.commission.percent, initial_capital=1000000,
//  default_qty_type=strategy.fixed)

filterBW = input(false, title="filter Bill Williams Fractals?")

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////// UTILITIES ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

//  ||-----------------------------------------------------------------------------------------------------||
//  ||---   Fractal Recognition Functions:  ---------------------------------------------------------------||
isRegularFractal(mode, _high, _low) =>
    ret = mode == 1 ? _high[4] < _high[3] and _high[3] < _high[2] and _high[2] > _high[1] and _high[1] > _high[0] :
     mode == -1 ? _low[4] > _low[3] and _low[3] > _low[2] and _low[2] < _low[1] and _low[1] < _low[0] : false

isBWFractal(mode, _high, _low) =>
    ret = mode == 1 ? _high[4] < _high[2] and _high[3] <= _high[2] and _high[2] >= _high[1] and _high[2] > _high[0] :
     mode == -1 ? _low[4] > _low[2] and _low[3] >= _low[2] and _low[2] <= _low[1] and _low[2] < _low[0] : false

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
////////////////////////////// ABCD PATTERN ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

f_abcd()=>

    _r = timeframe.period
    _g = barmerge.gaps_off
    _l = barmerge.lookahead_on

    _high = high
    _low = low

    filteredtopf = filterBW ? isRegularFractal(1, _high, _low) : isBWFractal(1, _high, _low)
    filteredbotf = filterBW ? isRegularFractal(-1, _high, _low) : isBWFractal(-1, _high, _low)

    //  ||---   ZigZag:
    istop = filteredtopf
    isbot = filteredbotf
    topcount = barssince(istop)
    botcount = barssince(isbot)

    zigzag = (istop and topcount[1] > botcount[1] ? _high[2] :
     isbot and topcount[1] < botcount[1] ? _low[2] : na)

    x = valuewhen(zigzag, zigzag, 4) 
    a = valuewhen(zigzag, zigzag, 3) 
    b = valuewhen(zigzag, zigzag, 2) 
    c = valuewhen(zigzag, zigzag, 1) 
    d = valuewhen(zigzag, zigzag, 0)

    xab = (abs(b-a)/abs(x-a))
    xad = (abs(a-d)/abs(x-a))
    abc = (abs(b-c)/abs(a-b))
    bcd = (abs(c-d)/abs(b-c))

    // ABCD Part
    _abc = abc >= 0.382 and abc <= 0.886
    _bcd = bcd >= 1.13 and bcd <= 2.618
    
    _bull_abcd = _abc and _bcd and d < c 
    _bear_abcd = _abc and _bcd and d > c

    _bull   = _bull_abcd and not _bull_abcd[1]
    _bear   = _bear_abcd and not _bear_abcd[1]

    [_bull, _bear, zigzag]

lapos_x = timenow + round(change(time)*12)

[isLong, isShort, zigzag]  = f_abcd()

plot(zigzag, title= 'ZigZag', color=color.black, offset=-2)
plotshape(isLong, style=shape.labelup, location=location.belowbar, color=color.new(color.green, 0), size=size.normal, text="ABCD", textcolor=color.white)
plotshape(isShort, style=shape.labeldown, location=location.abovebar, color=color.new(color.maroon, 0), size=size.normal, text="ABCD", textcolor=color.white)


long_entry_price    = valuewhen(isLong, close, 0)
short_entry_price   = valuewhen(isShort, close, 0)

sinceNUP = barssince(isLong)
sinceNDN = barssince(isShort)

buy_trend   = sinceNDN > sinceNUP
sell_trend  = sinceNDN < sinceNUP


//////////////////////////
//* Profit Component *//
//////////////////////////

//////////////////////////// MinTick ///////////////////////////
fx_pips_value = syminfo.type == "forex" ? syminfo.mintick*10 : 1

input_tp_pips = input(100, "Backtest Profit Goal (in USD)",minval=0)*fx_pips_value
input_sl_pips = input(20, "Backtest STOP Goal (in USD)",minval=0)*fx_pips_value

tp = buy_trend? long_entry_price + input_tp_pips : short_entry_price - input_tp_pips
sl = buy_trend? long_entry_price - input_sl_pips : short_entry_price + input_sl_pips

plot_tp = buy_trend and high[1] <= tp ? tp : sell_trend and low[1] <= tp ? tp : na
plot_sl = buy_trend and low[1] >= sl ? sl : sell_trend and high[1] >= sl ? sl : na

plot(plot_tp, title="TP", style=plot.style_circles, linewidth=3, color=color.blue)
plot(plot_sl, title="SL", style=plot.style_circles, linewidth=3, color=color.red)

longClose   = isShort
shortClose  = isLong


strategy.entry("Long", 1, when=isLong)
// strategy.close("Long", when=longClose )
strategy.exit("XL","Long", limit=tp,  when=buy_trend, stop=sl)


strategy.entry("Short", 0,  when=isShort)
// strategy.close("Short", when=shortClose )
strategy.exit("XS","Short", when=sell_trend, limit=tp, stop=sl)

अधिक