संसाधन लोड हो रहा है... लोड करना...
  1. वर्ग
  2. एडीएक्स-फ़िल्टर्ड सुपरट्रेंड पिवोट ट्रेडिंग रणनीति

एडीएक्स-फ़िल्टर्ड सुपरट्रेंड पिवोट ट्रेडिंग रणनीति

लेखक:चाओझांग, दिनांकः 2024-02-19 15:01:36
टैगः

img

अवलोकन

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

रणनीति तर्क

  1. पीवोट समर्थन और प्रतिरोध रेखाओं की गणना करें। समापन मूल्य लें और ऊपर और नीचे एटीआर रेंज जोड़ें/घटाएं। इन रेखाओं के टूटने से रुझान रिवर्स का संकेत मिलता है।

  2. एडीएक्स प्रवृत्ति की ताकत निर्धारित करता है। उच्च एडीएक्स मूल्य एक मजबूत प्रवृत्ति का संकेत देते हैं।

  3. व्यापार संकेतों के लिए दोनों को मिलाएं. केवल पिवोट ब्रेक और उच्च ADX पर लंबा/लघु जाएं.

लाभ विश्लेषण

इस रणनीति के फायदे:

  1. गतिशील सुपरट्रेंड लाइनें तेजी से ब्रेकआउट की पहचान करती हैं।

  2. एडीएक्स फ़िल्टर रेंज-बाउंड बाजारों के दौरान झूठे संकेतों से बचाता है।

  3. अच्छा जोखिम-लाभ अनुपात और उपयोग नियंत्रण।

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

इस रणनीति के जोखिमः

  1. अंतराल की चाल सुपरट्रेंड लाइनों को अमान्य कर सकती है।

  2. खराब एडीएक्स सीमा सेटिंग प्रदर्शन को प्रभावित करती है।

  3. उच्च व्यापारिक आवृत्ति से लेन-देन की लागत बढ़ जाती है।

समाधान:

  1. व्यापक ब्रेकआउट रेंज की अनुमति देने के लिए मापदंडों का अनुकूलन करें.

  2. बेहतर ADX मानों के लिए परीक्षण करें।

  3. व्यापार की आवृत्ति को कम करें।

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

सुधार के क्षेत्र:

  1. अधिक मजबूत लाइनों के लिए एटीआर गुणक को अनुकूलित करें.

  2. विभिन्न ADX मापदंडों का परीक्षण करें।

  3. घाटे को सीमित करने के लिए स्टॉप-लॉस जोड़ें।

निष्कर्ष

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

/*backtest
start: 2023-02-12 00:00:00
end: 2024-02-18 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("STPP20 + ADX", overlay = true)

///////////////////////////
// SuperTrend + Pivot Point
//////////////////////////

src =  input(close, title="EMA Source")
PPprd = input(defval = 2, title="Pivot Point Period", minval = 1, maxval = 50)
AtrFactor=input(defval = 5, title = "ATR Factor", minval = 1, step = 0.1)
AtrPd=input(defval = 20, title = "ATR Period", minval=1)

float ph = na
float pl = na
ph := pivothigh(PPprd, PPprd)
pl := pivotlow(PPprd, PPprd)

float center = na
center := center[1]
float lastpp = ph ? ph : pl ? pl : na
if lastpp
    if na(center)
        center := lastpp
    else
        center := (center * 2 + lastpp) / 3

Up = center - (AtrFactor * atr(AtrPd))
Dn = center + (AtrFactor * atr(AtrPd))

float TUp = na
float TDown = na
Trend = 0
TUp := close[1] > TUp[1] ? max(Up, TUp[1]) : Up
TDown := close[1] < TDown[1] ? min(Dn, TDown[1]) : Dn
Trend := close > TDown[1] ? 1: close < TUp[1]? -1: nz(Trend[1], 1)
Trailingsl = Trend == 1 ? TUp : TDown

// Lines
linecolor = Trend == 1 and nz(Trend[1]) == 1 ? color.lime : Trend == -1 and nz(Trend[1]) == -1 ? color.red : na
plot(Trailingsl, color = linecolor ,  linewidth = 2, title = "PP SuperTrend")

bsignalSSPP = close > Trailingsl
ssignalSSPP = close < Trailingsl


///////
// ADX
//////

lenADX = 14
th = 25
TrueRange = max(max(high-low, abs(high-nz(close[1]))), abs(low-nz(close[1])))
DirectionalMovementPlus = high-nz(high[1]) > nz(low[1])-low ? max(high-nz(high[1]), 0): 0
DirectionalMovementMinus = nz(low[1])-low > high-nz(high[1]) ? max(nz(low[1])-low, 0): 0
SmoothedTrueRange = 0.0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1])/lenADX) + TrueRange
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1])/lenADX) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus = 0.0
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1])/lenADX) + DirectionalMovementMinus
DIPlus = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIMinus = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = abs(DIPlus-DIMinus) / (DIPlus+DIMinus)*100
ADX = sma(DX, lenADX)


//////
// MA
/////

lenMA = 21
srcMA = input(close, title="Source")
offsetMA = input(title="Offset", type=input.integer, defval=0, minval=-500, maxval=500)
outMA = sma(srcMA, lenMA)


// Buy - Sell Entries
buy = bsignalSSPP and outMA < close and ADX > th
sell = ssignalSSPP 

if (buy)
    // .order // Tuned version
    strategy.entry("Buy", strategy.long)


if (sell) and (strategy.position_size > 0)
    strategy.order("Sell", false, when = sell)
अधिक

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