क्रॉस पीरियड ब्रेकथ्रू सिस्टम

लेखक:चाओझांग, दिनांकः 2023-11-22 15:22:49
टैगः

img

अवलोकन

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

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

रणनीति प्रवृत्ति की दिशा निर्धारित करने के लिए विभिन्न लंबाई के 3 एसएमएमए चलती औसत और 1 ईएमए चलती औसत का उपयोग करती है। साथ ही, यह अल्पकालिक रुझानों और प्रवेश के अवसरों का न्याय करने के लिए एमएसीडी संकेतक को जोड़ती है। विशेष रूप से, खरीद ट्रिगर स्थिति हैः कीमत सभी चलती औसत के माध्यम से ऊपर की ओर टूट जाती है, और छोटे औसत लंबे लोगों से ऊपर होते हैं; जबकि बिक्री ट्रिगर स्थिति विपरीत है, कीमत सभी चलती औसत के माध्यम से नीचे की ओर टूट जाती है, और छोटे औसत लंबे लोगों से नीचे होते हैं।

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

लाभ विश्लेषण

इस क्रॉस-पीरियड ऑपरेशन का लाभ यह है कि यह उच्च संभावना वाले रुझान की दिशा में प्रवेश करने के लिए उपयुक्त अल्पकालिक उलट बिंदुओं का चयन कर सकता है, जिससे बेहतर जोखिम-लाभ अनुपात प्राप्त होता है। विशेष रूप से, मुख्य रूप से निम्नलिखित 3 फायदे हैंः

  1. 3 एसएमएमए औसत और 1 ईएमए लाइन बहु-स्तरीय फ़िल्टरिंग प्रभावी रूप से मध्यम और दीर्घकालिक प्रवृत्ति दिशा निर्धारित कर सकती है ताकि प्रवृत्ति के खिलाफ व्यापार से बचा जा सके।

  2. प्रवेश के लिए अल्पकालिक उलट बिंदुओं का आकलन करने वाला एमएसीडी संकेतक बेहतर प्रवेश मूल्य स्तर प्राप्त कर सकता है।

  3. एक फ़िल्टरिंग स्थिति के रूप में सख्त चलती औसत अनुक्रम संबंध गलत संचालन की संभावना को कम कर सकता है।

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

इस रणनीति के मुख्य जोखिम निम्नलिखित हैंः

  1. मूविंग एवरेज में ही अधिक लेगिंग गुण होते हैं, जो अल्पकालिक रुझान उलटने के अवसरों को याद कर सकते हैं।

  2. एमएसीडी संकेतक झूठे संकेत उत्पन्न करने के लिए प्रवण हैं और उन्हें मूल्य स्तरों के साथ संयोजन में फ़िल्टर करने की आवश्यकता है।

  3. बहु-समय-सीमा निर्णयों से रणनीति की जटिलता बढ़ जाती है और असफलता की संभावना होती है।

जोखिम 1 और जोखिम 2 को संबोधित करने के लिए, हम अल्पकालिक रुझान उलटों पर जल्दी से प्रतिक्रिया करने के लिए चलती औसत और संकेत चक्र को उचित रूप से छोटा करके अनुकूलित कर सकते हैं। जोखिम 3 के लिए, हमें रणनीति मापदंडों को उस विविधता की विशेषताओं के लिए सख्ती से अनुकूलित करने के लिए विभिन्न किस्मों और चक्रों के लिए अनुकूलित और परीक्षण करने की आवश्यकता है।

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

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

  1. विभिन्न चक्रों और किस्मों की विशेषताओं के अनुरूप चलती औसत और एमएसीडी के मापदंडों का अनुकूलन करना। जैसे चलती औसत की लंबाई को छोटा करना, संकेत मापदंड को बढ़ाना, आदि।

  2. एटीआर या अन्य संकेतकों का उपयोग करके उचित चलती स्टॉप सेट करने के लिए स्टॉप लॉस रणनीतियों को बढ़ाएं। यह रणनीति के जोखिम नियंत्रण में काफी सुधार कर सकता है।

  3. एमएसीडी संकेतों को बदलने के लिए बेहतर संकेतकों या फ़िल्टरिंग विधियों की तलाश करें। उदाहरण के लिए, अस्थिरता संकेतकों को पेश करें और तदनुसार फ़िल्टर संकेत।

  4. बेहतर जोखिम-लाभ अनुपात के साथ पैरामीटर संयोजन प्राप्त करने के लिए लाभ और हानि अनुपात के विभिन्न संबंधों का परीक्षण करें।

सारांश

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


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

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © SoftKill21

//@version=4
strategy("Koala Script",initial_capital=1000, 
     commission_type=strategy.commission.cash_per_contract, 
     commission_value=0.000065,
     slippage=3)
fromDay = input(defval = 1, title = "From Day", minval = 1, maxval = 31)
fromMonth = input(defval = 1, title = "From Month", minval = 1, maxval = 12)
fromYear = input(defval = 2000, title = "From Year", minval = 1970)
 
// To Date Inputs
toDay = input(defval = 1, title = "To Day", minval = 1, maxval = 31)
toMonth = input(defval = 8, title = "To Month", minval = 1, maxval = 12)
toYear = input(defval = 2031, title = "To Year", minval = 1970)
 


startDate = timestamp(fromYear, fromMonth, fromDay, 00, 00)
finishDate = timestamp(toYear, toMonth, toDay, 00, 00)




len = input(3, minval=1, title="Length")
src = input(hl2, title="Source")
smma = 0.0
sma1 = sma(src, len)
smma := na(smma[1]) ? sma1 : (smma[1] * (len - 1) + src) / len

len2 = input(6, minval=1, title="Length")
src2 = input(hl2, title="Source")
smma2 = 0.0
sma2 = sma(src2, len2)
smma2 := na(smma2[1]) ? sma2 : (smma2[1] * (len2 - 1) + src2) / len2

len3 = input(9, minval=1, title="Length")
src3 = input(hl2, title="Source")
smma3 = 0.0
sma3 = sma(src3, len3)
smma3 := na(smma3[1]) ? sma3 : (smma3[1] * (len3 - 1) + src3) / len3

len4 = input(50, minval=1, title="Length")
src4 = input(close, title="Source")
smma4 = 0.0
sma4 = sma(src4, len4)
smma4 := na(smma4[1]) ? sma4  : (smma4[1] * (len4 - 1) + src4) / len4

len5 = input(200, minval=1, title="Length")
src5 = input(close, title="Source")
out5 = ema(src5, len5)

timeinrange(res, sess) => time(res, sess) != 0
london=timeinrange(timeframe.period, "0300-1045")
londonEntry=timeinrange(timeframe.period, "0300-0845")

time_cond = time >= startDate and time <= finishDate and londonEntry

fast_length = input(title="Fast Length", type=input.integer, defval=12)
slow_length = input(title="Slow Length", type=input.integer, defval=26)
srcc = input(title="Source", type=input.source, defval=close)
signal_length = input(title="Signal Smoothing", type=input.integer, minval = 1, maxval = 50, defval = 9)
sma_source = input(title="Simple MA(Oscillator)", type=input.bool, defval=false)
sma_signal = input(title="Simple MA(Signal Line)", type=input.bool, defval=false)


// Calculating
fast_ma = sma_source ? sma(srcc, fast_length) : ema(srcc, fast_length)
slow_ma = sma_source ? sma(srcc, slow_length) : ema(srcc, slow_length)
macd = fast_ma - slow_ma
signal = sma_signal ? sma(macd, signal_length) : ema(macd, signal_length)
hist = macd - signal


longCond = close > out5 and close > smma4 and close > smma3 and close > smma2 and close > smma and londonEntry and smma > smma2 and smma2>smma3 and smma3>smma4 and smma4>out5 
shortCond = close < out5 and close < smma4 and close < smma3 and close < smma2 and close < smma and londonEntry and smma < smma2 and smma2<smma3 and smma3<smma4 and smma4<out5 
//longCond2 = crossover(close,out5) and crossover(close,smma4) and crossover(close,smma3) and crossover(close,smma2) and crossover(close,smma) and time_cond
//shortCond2 = crossunder(close,out5) and crossunder(close,smma4) and crossunder(close,smma3) and crossunder(close,smma2) and crossunder(close,smma) and time_cond

length=input(14, title="ATR Length")
mult=input(1.0, title="Percentage Multiplier (for ex., 0.7 = 70%)", step=0.1, minval=0.1, maxval=5.0)

oa=input(false, title="Show actual ATR")

ii=syminfo.pointvalue==0
s=ii?na:oa?atr(length):(syminfo.pointvalue * mult * atr(length))

tp=input(300,title="tp")
sl=input(300,title="sl")


//tp = s*10000
//sl= s*10000



//if(tp>300)
//    tp:=300
//if(sl>300)
//    sl:=300
//if(sl<150)
//    sl:=150
//if(tp<150)
//    tp:=150
strategy.initial_capital = 50000
//MONEY MANAGEMENT--------------------------------------------------------------''
balance = strategy.netprofit + strategy.initial_capital //current balance
floating = strategy.openprofit          //floating profit/loss
risk = input(3,type=input.float,title="Risk %")/100           //risk % per trade


    //Calculate the size of the next trade
temp01 = balance * risk     //Risk in USD
temp02 = temp01/sl        //Risk in lots
temp03 = temp02*100000      //Convert to contracts
size = temp03 - temp03%1000 //Normalize to 1000s (Trade size)
if(size < 10000)
    size := 10000           //Set min. lot size



strategy.entry("long",1,when=longCond )
strategy.exit("closelong","long", profit=tp,loss=sl)
//strategy.close("long",when= crossunder(close[4],smma4) and close[4] > close[3] and close[3]>close[2] and close[2] > close[1] and close[1] > close)
strategy.entry("short",0,when=shortCond )
strategy.exit("closeshort","short", profit=tp,loss=sl)
//strategy.close("short",when= crossover(close[4],smma4) and close[4] < close[3] and close[3]< close[2] and close[2] < close[1] and close[1] < close)

strategy.close_all(when = not london)

maxEntry=input(2,title="max entries")
// strategy.risk.max_intraday_filled_orders(maxEntry)

अधिक