संसाधन लोड हो रहा है... लोड करना...
  1. वर्ग
  2. डोंचियन चैनल ब्रेकआउट ट्रेडिंग रणनीति

डोंचियन चैनल ब्रेकआउट ट्रेडिंग रणनीति

लेखक:चाओझांग, दिनांक: 2023-11-08 12:31:56
टैगः

img

अवलोकन

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

रणनीति तर्क

यह रणनीति पिछले ऐतिहासिक अवधियों में उच्चतम मूल्य पीसीमैक्स और निम्नतम मूल्य पीसीमिन की गणना करके एक चैनल का निर्माण करती है। चैनल के ऊपरी और निचले रेल के लिए गणना के तरीके हैंः

ऊपरी रेल yh = pcmax - (pcmax - pcmin) * (100 - प्रतिशतDev)/100

लोअर रेल yl = पीसीमिन + (पीसीमैक्स - पीसीमिन) * प्रतिशतDev/100

जहां प्रतिशतDev 13 के लिए डिफ़ॉल्ट है

एक लंबा संकेत तब उत्पन्न होता है जब कीमत ऊपरी रेल को तोड़ती है। एक छोटा संकेत तब उत्पन्न होता है जब कीमत निचली रेल को तोड़ती है।

ट्रेडिंग सिग्नल उत्पन्न करने का विशिष्ट तर्क हैः

  1. boundup = high > yh यह निर्धारित करने के लिए कि क्या ऊपरी रेल टूट गई है

  2. bounddn = कम < yl यह निर्धारित करने के लिए कि क्या निचला रेल टूटा हुआ है

  3. upsign = sma(bounddn, 2) == 1 निचले रेल के निरंतर ब्रेकआउट को निर्धारित करने के लिए bounddn के sma का उपयोग करता है

  4. dnsign = sma(बाउंडअप, 2) == 1 ऊपरी रेल के निरंतर ब्रेकआउट को निर्धारित करने के लिए बंधन के sma का उपयोग करता है

  5. exitup = dnsign ऊपरी रेल का ब्रेकआउट आउटपुट सिग्नल उत्पन्न करता है

  6. exitdn = upsign निचले रेल का ब्रेकआउट आउट सिग्नल उत्पन्न करता है

  7. यदि निचले रेल के अपसिग्न ब्रेकआउट से लंबा सिग्नल उत्पन्न होता है

  8. यदि ऊपरी रेल के dnsign ब्रेकआउट से शॉर्ट सिग्नल उत्पन्न होता है

रणनीति अनावश्यक ओवरनाइट पदों से बचने के लिए व्यापार शुरू करने और समाप्त करने के समय भी निर्धारित करती है।

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

  1. रुझानों को निर्धारित करने के लिए डोनचियन चैनल का उपयोग करता है, अच्छा बैकटेस्ट परिणाम

  2. दोनों लंबे और छोटे संकेत है, दो तरफा व्यापार की अनुमति देता है

  3. संकेतों को फ़िल्टर करने और खराब ट्रेडों से बचने के लिए SMA का उपयोग करता है

  4. जोखिमों को नियंत्रित करने के लिए वैकल्पिक स्टॉप लॉस

  5. ओवरनाइट जोखिमों से बचने के लिए व्यापार शुरू करने और समाप्त करने के समय निर्धारित करें

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

  1. इतिहास और प्रतिशतDev मापदंडों के लिए संवेदनशील, विभिन्न उत्पादों के लिए अनुकूलन की जरूरत है

  2. रेंज-बाउंड बाजारों में झूठे संकेत उत्पन्न कर सकता है

  3. ऑर्डर प्रबंधन पर विचार नहीं करता है, लाइव ट्रेडिंग में लाभप्रदता को प्रभावित कर सकता है

  4. पदों के आकार को ध्यान में नहीं रखता, अति-आकार की स्थिति के जोखिम

  5. धन प्रबंधन पर विचार नहीं करता, उचित व्यापारिक पूंजी की आवश्यकता होती है

सुधार के विचार

  1. विभिन्न उत्पादों के लिए इतिहास और प्रतिशतDev पैरामीटर अनुकूलित करें

  2. विभिन्न बाजारों में झूठे संकेतों से बचने के लिए फ़िल्टर जोड़ें

  3. एकल स्थिति आकार को नियंत्रित करने के लिए स्थिति आकार मॉड्यूल जोड़ें

  4. कुल स्थिति आकार को सीमित करने के लिए धन प्रबंधन मॉड्यूल जोड़ें

  5. ऑर्डर निष्पादन के लिए ऑर्डर प्रबंधन जोड़ें

निष्कर्ष

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

/*backtest
start: 2023-10-31 00:00:00
end: 2023-11-07 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

////////////////////////////////////////////////////////////
//  Copyright by AlexInc v1.0 02/07/2018  @aav_1980
// PriceChannel strategy
// If you find this script helpful, you can also help me by sending donation to 
// BTC 16d9vgFvCmXpLf8FiKY6zsy6pauaCyFnzS
// LTC LQ5emyqNRjdRMqHPHEqREgryUJqmvYhffM
////////////////////////////////////////////////////////////
//@version=3
strategy("AlexInc PriceChannel Str", overlay=false)
history = input(20)
percentDev = input(13)
capital = input(100)

needlong = input(true, defval = true, title = "Long")
needshort = input(true, defval = true, title = "Short")
usestoploss = input(true, defval = true, title = "Stop Loss")
stoplossmult = input(3.8, defval = 3.8, minval = 1, maxval = 10, title = "Stop loss multiplicator")


fromyear = input(2018, defval = 2018, minval = 1900, maxval = 2100, title = "From Year")
toyear = input(2100, defval = 2100, minval = 1900, maxval = 2100, title = "To Year")
frommonth = input(01, defval = 01, minval = 01, maxval = 12, title = "From Month")
tomonth = input(12, defval = 12, minval = 01, maxval = 12, title = "To Month")
fromday = input(01, defval = 01, minval = 01, maxval = 31, title = "From day")
today = input(31, defval = 31, minval = 01, maxval = 31, title = "To day")

bodymin = min( open, close)
bodymax = max(open, close)

pcmax = highest(bodymax, history)
pcmin = lowest(bodymin, history)

yh = ((pcmax - pcmin) / 100 * (100 - percentDev)) + pcmin
yl = ((pcmax - pcmin) / 100 * percentDev) + pcmin

plot(pcmax)
plot(pcmin)
plot(yh)
plot(yl)

//1
bounddn = low < yl ? 1 : 0
boundup = high > yh ? 1 : 0
upsign = sma(bounddn, 2) == 1
dnsign = sma(boundup, 2) == 1
//2
//upsign = crossover(bodymin, yl)
//dnsign = crossunder(bodymax , yh)


exitup = dnsign
exitdn = upsign

lot = strategy.equity / close * capital / 100


xATR = atr(history)
nLoss = usestoploss ? stoplossmult * xATR : na

stop_level_long = 0.0
stop_level_long := nz(stop_level_long[1])

stop_level_short = 0.0
stop_level_short := nz(stop_level_short[1])

pos = strategy.position_size
if pos >0 and pos[1] <= 0 //crossover(pos, 0.5)
    stop_level_long = strategy.position_avg_price - nLoss
if pos < 0 and pos[1] >= 0 //crossunder(pos, -0.5)
    stop_level_short = strategy.position_avg_price + nLoss
if pos == 0    
    stop_level_long = bodymin - nLoss
    stop_level_short = bodymax + nLoss

//plot(bodymax + nLoss, color=red)
//plot(bodymin - nLoss, color=red)
plot(stop_level_long, color=red)
plot(stop_level_short, color=red)

if upsign
    strategy.entry("Long", strategy.long, needlong == false ? 0 : lot)

if dnsign
    strategy.entry("Short", strategy.short, needshort == false ? 0 : na)

if true
    strategy.close_all()


//if strategy.position_size != 0
//    strategy.exit("Exit Long", from_entry = "Long", stop = stop_level_long)
//    strategy.exit("Exit Short", from_entry = "Short", stop = stop_level_short)
अधिक

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