मोमेंटम टीडी रिवर्सल ट्रेडिंग रणनीति

लेखक:चाओझांग, दिनांक: 2023-12-18 17:40:10
टैगः

img

अवलोकन

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

रणनीति तर्क

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

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

फायदे का विश्लेषण

  • पूर्व में मूल्य उलटने के अवसरों की पहचान करने के लिए TD अनुक्रमिक संकेतक का उपयोग करें
  • समयबद्ध तरीके से कीमतों में बदलाव की पुष्टि करने के लिए चेस-राइज-किल-ड्रॉप तंत्र की स्थापना
  • अपेक्षाकृत बेहतर प्रवेश बिंदु प्राप्त करने के लिए प्रतिवर्तन के गठन चरण में पदों में प्रवेश करें

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

  • टीडी अनुक्रमिक संकेतक में झूठे ब्रेकआउट हो सकते हैं। संकेतों की पुष्टि करने के लिए अन्य कारकों की आवश्यकता होती है
  • जोखिमों को कम करने के लिए स्थिति के आकार और धारण अवधि को उचित रूप से नियंत्रित करें

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

  • झूठे ब्रेकआउट जोखिमों से बचने के लिए रिवर्स सिग्नल को मान्य करने के लिए अन्य संकेतकों को शामिल करें
  • एकल व्यापार हानि को नियंत्रित करने के लिए स्टॉप लॉस तंत्र की स्थापना
  • लाभ पैमाने और जोखिम प्रबंधन को संतुलित करने के लिए स्थिति आकार और धारण अवधि को अनुकूलित करें

निष्कर्ष

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


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

//@version=4
//This strategy is based on TD sequential study from glaz. 
//I made some improvement and modification to comply with pine script version 4.
//Basically, it is a strategy based on proce action, supports and resistance.

strategy("Sequential Up/Down", overlay=true )
source = input(close)
BarsCount = input(9, "Count of consecutive bars")
useLinearRegression = input(false)
LR_length = input(13,"Linear Regression length")
SR = input(true,"Shows Supports and Resistance lines")
Barcolor = input(true,"Color bars when there is a signal")
transp = input(0, "Transparency of triangle Up or Downs")
Numbers = input(true,"Plot triangle Up or Downs at signal")

//Calculation
src=useLinearRegression?linreg(source,LR_length,0):source
UP = 0
DW = 0
UP := src > src[4] ? nz(UP[1]) + 1 : 0
DW := src < src[4] ? nz(DW[1]) + 1 : 0

UPUp = UP - valuewhen(UP < UP[1], UP, 1)
DWDn = DW - valuewhen(DW < DW[1], DW, 1)

plotshape(Numbers ? UPUp == BarsCount ? true : na : na, style=shape.triangledown, text="", color=color.green, location=location.abovebar, transp=transp)
plotshape(Numbers ? DWDn == BarsCount ? true : na : na, style=shape.triangleup, text="", color=color.red, location=location.belowbar, transp=transp)


// S/R Code By johan.gradin
//------------//
// Sell Setup //
//------------//
priceflip = barssince(src < src[4])
sellsetup = src > src[4] and priceflip
sell = sellsetup and barssince(priceflip != BarsCount)
sellovershoot = sellsetup and barssince(priceflip != BarsCount+4)
sellovershoot1 = sellsetup and barssince(priceflip != BarsCount+5)
sellovershoot2 = sellsetup and barssince(priceflip != BarsCount+6)
sellovershoot3 = sellsetup and barssince(priceflip != BarsCount+7)

//----------//
// Buy setup//
//----------//
priceflip1 = barssince(src > src[4])
buysetup = src < src[4] and priceflip1
buy = buysetup and barssince(priceflip1 != BarsCount)
buyovershoot = barssince(priceflip1 != BarsCount+4) and buysetup
buyovershoot1 = barssince(priceflip1 != BarsCount+5) and buysetup
buyovershoot2 = barssince(priceflip1 != BarsCount+6) and buysetup
buyovershoot3 = barssince(priceflip1 != BarsCount+7) and buysetup

//----------//
// TD lines //
//----------//
TDbuyh = valuewhen(buy, high, 0)
TDbuyl = valuewhen(buy, low, 0)
TDsellh = valuewhen(sell, high, 0)
TDselll = valuewhen(sell, low, 0)

//----------//
//   Plots  //
//----------//

plot(SR ? TDbuyh ? TDbuyl : na : na, style=plot.style_circles, linewidth=1, color=color.red)
plot(SR ? TDselll ? TDsellh : na : na, style=plot.style_circles, linewidth=1, color=color.lime)
barcolor(Barcolor ? sell ? #FF0000 : buy ? #00FF00 : sellovershoot ? #FF66A3 : sellovershoot1 ? #FF3385 : sellovershoot2 ? #FF0066 : sellovershoot3 ? #CC0052 : buyovershoot ? #D6FF5C : buyovershoot1 ? #D1FF47 : buyovershoot2 ? #B8E62E : buyovershoot3 ? #8FB224 : na : na)

//  Strategy: (Thanks to JayRogers)
// === STRATEGY RELATED INPUTS ===
//tradeInvert     = input(defval = false, title = "Invert Trade Direction?")
// the risk management inputs
inpTakeProfit   = input(defval = 0, title = "Take Profit Points", minval = 0)
inpStopLoss     = input(defval = 0, title = "Stop Loss Points", minval = 0)
inpTrailStop    = input(defval = 100, title = "Trailing Stop Loss Points", minval = 0)
inpTrailOffset  = input(defval = 0, title = "Trailing Stop Loss Offset Points", minval = 0)

// === RISK MANAGEMENT VALUE PREP ===
// if an input is less than 1, assuming not wanted so we assign 'na' value to disable it.
useTakeProfit   = inpTakeProfit  >= 1 ? inpTakeProfit  : na
useStopLoss     = inpStopLoss    >= 1 ? inpStopLoss    : na
useTrailStop    = inpTrailStop   >= 1 ? inpTrailStop   : na
useTrailOffset  = inpTrailOffset >= 1 ? inpTrailOffset : na

// === STRATEGY - LONG POSITION EXECUTION ===
enterLong() => buy or buyovershoot or buyovershoot1 or buyovershoot2 or buyovershoot3// functions can be used to wrap up and work out complex conditions
//exitLong() => oscillator <= 0
strategy.entry(id = "Buy", long = true, when = enterLong() )// use function or simple condition to decide when to get in
//strategy.close(id = "Buy", when = exitLong() )// ...and when to get out

// === STRATEGY - SHORT POSITION EXECUTION ===
enterShort() => sell or sellovershoot or sellovershoot2 or sellovershoot3
//exitShort() => oscillator >= 0
strategy.entry(id = "Sell", long = false, when = enterShort())
//strategy.close(id = "Sell", when = exitShort() )

// === STRATEGY RISK MANAGEMENT EXECUTION ===
// finally, make use of all the earlier values we got prepped
strategy.exit("Exit Buy", from_entry = "Buy", profit = useTakeProfit, loss = useStopLoss, trail_points = useTrailStop, trail_offset = useTrailOffset)
strategy.exit("Exit Sell", from_entry = "Sell", profit = useTakeProfit, loss = useStopLoss, trail_points = useTrailStop, trail_offset = useTrailOffset)



अधिक