यह रणनीति मूल्य रुझानों को निर्धारित करने और ब्रेकआउट का पालन करने के लिए गुरुत्वाकर्षण के केंद्र सूचक और एसएसएल चैनल सूचक को जोड़ती है, जो प्रवृत्ति के बाद की रणनीति श्रेणी से संबंधित है। यह जोखिमों को नियंत्रित करने के लिए गतिशील एटीआर स्टॉप लॉस का भी उपयोग करता है।
ऊपर और नीचे के रुझानों के लिए सीमाओं के रूप में ऊपरी और निचले बैंड के साथ गुरुत्वाकर्षण केंद्र संकेतक की गणना करें।
एसएसएल चैनल संकेतक की गणना करें, जिसके भीतर सीमा है, बाहर प्रवृत्ति दिशा है।
जब कीमत ऊपरी बैंड या चैनल को तोड़ती है, तो अपट्रेंड निर्धारित करें और लंबे समय तक जाएं। जब कीमत निचले बैंड या चैनल को तोड़ती है, तो डाउनट्रेंड निर्धारित करें और शॉर्ट जाएं।
गतिशील एटीआर स्टॉप लॉस का उपयोग स्टॉप लॉस स्तरों को ट्रेल करने और बढ़े हुए नुकसान से बचने के लिए करें।
वास्तविक ट्रेडिंग संकेत उत्पन्न करने के लिए बैकटेस्ट अवधि के साथ संयोजन करें।
यह रणनीति रुझानों को निर्धारित करने के लिए दो संकेतकों का उपयोग करती है, एक ब्रेकआउट का पता लगाने के लिए और एक रुझानों की पुष्टि करने के लिए, उन्हें मिलाकर सटीकता में सुधार किया जा सकता है। गतिशील स्टॉप लॉस बाजार की अस्थिरता के आधार पर समायोजित होता है, जिससे यह एक बहुत ही व्यावहारिक जोखिम नियंत्रण विधि बन जाती है।
दो संकेतकों का उपयोग करने से रुझानों को निर्धारित करने में सटीकता बढ़ जाती है।
गुरुत्वाकर्षण का केंद्र प्रवृत्ति परिवर्तन के प्रति संवेदनशील है, एसएसएल चैनल प्रवृत्ति दिशा को स्पष्ट रूप से परिभाषित करता है।
गतिशील एटीआर स्टॉप लॉस को बाजार की अस्थिरता के आधार पर लचीलापन से समायोजित किया जाता है।
सरल और स्पष्ट रणनीति नियम, समझने और लागू करने में आसान।
मापदंडों के लिए बड़े अनुकूलन स्थान, विभिन्न बाजारों के लिए समायोजित किया जा सकता है।
रणनीति के प्रदर्शन को सत्यापित करने के लिए पूर्ण बैकटेस्ट कार्यक्षमता।
गुरुत्वाकर्षण के केंद्र और एसएसएल दोनों कुछ मामलों में विफल हो सकते हैं, जिससे गलत संकेत हो सकते हैं। पुष्टि के लिए अन्य संकेतक जोड़ सकते हैं।
गतिशील स्टॉप लॉस बहुत आक्रामक हो सकता है, स्टॉप लॉस रेंज को ढीला कर सकता है।
गलत बैकटेस्ट अवधि चयन से खराब रणनीति परिणाम हो सकते हैं, विभिन्न बाजार चरणों पर बैकटेस्ट करने की आवश्यकता हो सकती है।
व्यापार लागतों के प्रभाव को पूरी तरह से विचार करने की आवश्यकता है।
इष्टतम जोड़े खोजने के लिए विभिन्न पैरामीटर संयोजनों का परीक्षण करें।
गतिशील स्टॉप लॉस एटीआर अवधि और गुणक मापदंडों का अनुकूलन करें।
सिग्नल फ़िल्टरिंग के लिए अन्य संकेतक पेश करें, जैसे MACD, KDJ।
ट्रेंड दिशा भविष्यवाणी में सहायता के लिए मशीन लर्निंग मॉडल जोड़ें।
धन प्रबंधन को अनुकूलित करें, स्थिति आकार के नियम निर्धारित करें।
विशिष्ट उत्पादों के लिए परिष्कृत समायोजन पैरामीटर।
यह रणनीति ट्रेंड निर्धारित करने के लिए गुरुत्वाकर्षण के केंद्र और एसएसएल चैनल को जोड़ती है, और जोखिमों को नियंत्रित करने के लिए गतिशील एटीआर स्टॉप लॉस का उपयोग करती है। यह एक कार्रवाई योग्य ट्रेंड फॉलोअप रणनीति है। पैरामीटर अनुकूलन, अन्य संकेतकों और मशीन लर्निंग आदि की शुरुआत के माध्यम से आगे के सुधार किए जा सकते हैं। कुल मिलाकर यह एक अत्यधिक व्यावहारिक और विस्तार योग्य रणनीति है, जो एल्गोरिथम ट्रेडिंग के लिए एक मूल्यवान संदर्भ के रूप में कार्य करती है।
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-13 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Thanks to HPotter for the original code for Center of Gravity Backtest
strategy("CoG SSL BF 🚀", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
/////////////// Time Frame ///////////////
_0 = input(false, "════════ Test Period ═══════")
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
/////////////// SSL Channels ///////////////
_1 = input(false, "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)
smaHigh = sma(high, len1)
smaLow = sma(low, len2)
Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////// Center of Gravity /////////////
_2 = input(false, "═════════ CoG ══════════")
Length = input(25, minval=1)
m = input(5, minval=0)
Percent = input(6, minval=0, title="COG %")
xLG = linreg(close, Length, m)
xLG1r = xLG + ((close * Percent) / 100)
xLG1s = xLG - ((close * Percent) / 100)
pos = 0.0
pos := iff(close > xLG1r, 1, iff(close < xLG1s, -1, nz(pos[1], 0)))
possig = iff(pos == 1, 1, iff(pos == -1, -1, pos))
///////////// Rate Of Change /////////////
_3 = input(false, "══════ Rate of Change ══════")
source = close
roclength = input(2, "ROC Length", minval=1)
pcntChange = input(10, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Srategy ///////////////
long = possig == 1 or (sslUp > sslDown and isMoving())
short = possig == -1 or (sslUp < sslDown and isMoving())
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
atrLkb = input(1, minval=1, title='ATR Stop Period')
atrMult = input(2, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop = 0.0
longStop := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=longStop, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=shortStop, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
p1 = plot(sslDown, linewidth = 1, color=color.red, title="SSL down")
p2 = plot(sslUp, linewidth = 1, color=color.lime, title="SSL up")
fill(p1, p2, color = not isMoving() ? color.white : sslDown < sslUp ? color.lime : color.red, transp=80)
plot(xLG1r, color=color.lime, title="LG1r")
plot(xLG1s, color=color.red, title="LG1s")
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=1)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=1)
bgcolor(long ? color.green : short ? color.red : not isMoving() ? color.white : na, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)