ब्रेकआउट मोमेंटम पर नज़र रखने वाली टर्टल ट्रेडिंग रणनीति


निर्माण तिथि: 2023-12-25 17:12:05 अंत में संशोधित करें: 2023-12-25 17:12:05
कॉपी: 0 क्लिक्स: 429
1
ध्यान केंद्रित करना
1179
समर्थक

ब्रेकआउट मोमेंटम पर नज़र रखने वाली टर्टल ट्रेडिंग रणनीति

अवलोकन

Turtle Trading Strategy एक ट्रेंड ट्रैकिंग रणनीति है जो ब्रेकआउट की गतिशीलता को ट्रैक करती है। यह 1980 के दशक में प्रसिद्ध व्यापारी रिचर्ड डेनिस द्वारा विकसित की गई थी, ताकि यह सत्यापित किया जा सके कि क्या व्यापारियों को नियमों के माध्यम से प्रशिक्षित किया जा सकता है, न कि जन्मजात। इस रणनीति का मूल मनोविज्ञान मूल्य ब्रेकआउट को ट्रैक करना और ट्रेंड को ट्रैक करना है, जबकि नीचे जाने के जोखिम को सीमित करने के लिए धन प्रबंधन सिद्धांतों का सख्ती से पालन करना है।

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

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

कोड में, एन के अनुरूपenter_slowN/2 के अनुरूपenter_fastपिछले 55 दिनों और 20 दिनों के उच्चतम मूल्य के अनुसारslowLऔरfastL) न्यूनतम मूल्यlowest(slowSfastS)。当价格超过55天通道时做多(enterL2),当价格跌破20天通道时平多仓(exitL1);当价格跌破55天通道时做空(enterS2),当价格超过20天通道时平空仓(exitS1`)。

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

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

एक और लाभ यह है कि पैरामीटर का चयन सरल है। पूरी रणनीति में केवल 4 पैरामीटर हैं, जिन्हें समझना और समायोजित करना आसान है। पैरामीटर स्वयं स्थिर हैं, जिन्हें अक्सर अनुकूलित करने की आवश्यकता नहीं है।

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

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

इसके अलावा, निश्चित पैरामीटर सेटिंग्स भी विभिन्न किस्मों और बाजार की परिस्थितियों में बहुत भिन्न हो सकती हैं। इसे मैन्युअल अनुभव के साथ समायोजित करने की आवश्यकता होती है।

अनुकूलन दिशा

समुद्री तटीय व्यापार रणनीतियों को निम्नलिखित पहलुओं से अनुकूलित किया जा सकता हैः

  1. अतिरिक्त पैरामीटर अनुकूलन फ़ंक्शन। N, N / 2 के पैरामीटर को बाजार की अस्थिरता और सिग्नल आवृत्ति के आधार पर स्वचालित रूप से समायोजित करने की अनुमति देता है, और अधिक परिदृश्यों के लिए अनुकूलित करता है।

  2. प्रवृत्ति का आकलन करने के लिए नियम जोड़ें। प्रवृत्ति की दिशा का आकलन करने से पहले, कीमतों में उतार-चढ़ाव की स्थिति में गलत प्रवेश से बचें।

  3. कई समय अवधि की एकता रणनीतियों के संयोजन में। उच्च समय अवधि में प्रवृत्ति की दिशा निर्धारित करें, कम समय अवधि में प्रवेश करें।

  4. ट्रेलिंग स्टॉप या टाइम स्टॉप, कम वापसी।

संक्षेप

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

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

//@version=2
//oringinally coded by tmr0, modified by timchep
//original idea from «Way of the Turtle: The Secret Methods that Turned Ordinary People into Legendary Traders» (2007) CURTIS FAITH
strategy("Turtles", shorttitle = "Turtles", overlay=true, pyramiding=1, default_qty_type= strategy.percent_of_equity, default_qty_value = 100)
//////////////////////////////////////////////////////////////////////
// Component Code Start
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(12, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)

// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=false)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
// Component Code Stop
//////////////////////////////////////////////////////////////////////

shortingEnabled = input(title="Enable Shorting?", type=bool, defval=true)

enter_fast = input(20, minval=1)
exit_fast = input(10, minval=1)
enter_slow = input(55, minval=1)
exit_slow = input(20, minval=1)

fastL = highest(enter_fast)
fastLC = lowest(exit_fast)
fastS = lowest(enter_fast)
fastSC = highest(exit_fast)

slowL = highest(enter_slow)
slowLC = lowest(exit_slow)
slowS = lowest(enter_slow)
slowSC = highest(exit_slow)

enterL1 = high > fastL[1] 
exitL1 = low <= fastLC[1] 
enterS1 = low < fastS[1]
exitS1 = high >= fastSC[1]

enterL2 = high > slowL[1] 
exitL2 = low <= slowLC[1] 
enterS2 = low < slowS[1]
exitS2 = high >= slowSC[1]


if testPeriod()
    strategy.entry("fast L", strategy.long, when = enterL1) 
    
    if not enterL1
        strategy.entry("slow L", strategy.long, when = enterL2)
        
    strategy.close("fast L", when = exitL1)
    strategy.close("slow L", when = exitL2)

if shortingEnabled and testPeriod()
    strategy.entry("fast S", strategy.short, when = enterS1)
    if not enterS2
        strategy.entry("slow S", strategy.short, when = enterS2)
        
    strategy.close("fast S", when = exitS1)
    strategy.close("slow S", when = exitS2)