ianzeng123
2
ध्यान केंद्रित करना
319
समर्थक
अवलोकन
यह रणनीति एक एकीकृत ट्रेडिंग प्रणाली है जिसमें गॉस चैनल फ़िल्टर और यादृच्छिक आरएसआई संकेतक शामिल हैं। गॉस चैनल के दिशात्मक परिवर्तनों और मूल्य स्थान के माध्यम से, यादृच्छिक आरएसआई के साथ ओवरबॉय ओवरसोल सिग्नल के साथ व्यापार के अवसरों को निर्धारित किया जाता है। यह रणनीति अनुकूलन चैनल बनाने के लिए जटिल गणितीय मॉडल का उपयोग करती है, जो बाजार के शोर को प्रभावी ढंग से फ़िल्टर करने और महत्वपूर्ण मूल्य परिवर्तनों को पकड़ने में सक्षम है।
रणनीति सिद्धांत
रणनीति का मूल तर्क निम्नलिखित प्रमुख घटकों पर आधारित है:
- Gaussian channel computation: बहुध्रुवीय Gaussian filter का उपयोग HLC3 मूल्य डेटा को संसाधित करने के लिए किया जाता है ताकि एक अनुकूलनशील चैनल बनाया जा सके। Beta और alpha पैरामीटर के माध्यम से फ़िल्टर प्रभाव को अनुकूलित किया जा सकता है और वैकल्पिक रूप से विलंबता को कम किया जा सकता है।
- चैनल चौड़ाई समायोजनः चैनल चौड़ाई को वास्तविक तरंग दैर्ध्य के आधार पर गतिशील रूप से समायोजित करें, 1.414 को डिफ़ॉल्ट गुणांक के रूप में उपयोग करें।
- यादृच्छिक आरएसआई सिग्नलः 14 चक्र आरएसआई और एक यादृच्छिक सूचक के संयोजन से 80 से ऊपर या 20 से नीचे संकेत मिलता है।
- प्रवेश की शर्तें: एक साथ तीन शर्तों को पूरा करना आवश्यक है: गॉस चैनल ऊपर, कीमतों में वृद्धि, और यादृच्छिक आरएसआई ट्रिगर सिग्नल।
- आउटपुट लॉजिकः जब कीमत गॉस चैनल से नीचे जाती है, तो वह बंद हो जाती है।
रणनीतिक लाभ
- सिग्नल विश्वसनीयता: बहु-सूचक पुष्टिकरण तंत्र ने ट्रेडिंग सिग्नल की विश्वसनीयता में उल्लेखनीय वृद्धि की।
- अनुकूलन क्षमताः गॉस चैनल स्वचालित रूप से बाजार में उतार-चढ़ाव के आधार पर चैनल की चौड़ाई को समायोजित कर सकता है।
- शोर फ़िल्टरिंगः गॉस फ़िल्टर बाजार शोर के प्रभाव को कम करने के लिए प्रभावी है।
- उच्च लचीलापनः कई समायोज्य पैरामीटर प्रदान करता है, जिसमें चैनल चक्र, ध्रुवीय बिंदुओं की संख्या और आरएसआई पैरामीटर शामिल हैं।
- विजुअल इंटुसिव: रंग परिवर्तन के माध्यम से ट्रेंड दिशा और ट्रेडिंग सिग्नल को दिखाने के लिए।
रणनीतिक जोखिम
- पैरामीटर संवेदनशीलताः गॉस चैनल के ध्रुवों की संख्या और नमूना चक्र सेटिंग्स रणनीति के प्रदर्शन को प्रभावित करते हैं।
- पिछड़ेपन का खतरा: पिछड़ेपन को कम करने के लिए विकल्प उपलब्ध कराए जाने के बावजूद, सूचकांक में ही कुछ पिछड़ापन है।
- झूठी दरार का खतराः पारदर्शी बाजारों में अक्सर झूठी दरार के संकेत मिल सकते हैं।
- धन प्रबंधन की कमीः वर्तमान संस्करण में विस्तृत स्थिति प्रबंधन तंत्र की कमी है।
रणनीति अनुकूलन दिशा
- बाजार परिवेश पहचानः प्रवृत्ति की ताकत के संकेतकों को जोड़ना, विभिन्न बाजार स्थितियों में रणनीति पैरामीटर को समायोजित करना।
- गतिशील पैरामीटर अनुकूलनः बाजार में उतार-चढ़ाव के आधार पर स्वचालित रूप से गॉस चैनल के पैरामीटर सेटिंग्स को समायोजित करें।
- स्थिति प्रबंधन में सुधारः अस्थिरता के आधार पर गतिशील स्थिति प्रबंधन प्रणाली की शुरूआत।
- अतिरिक्त निकासी तंत्रः बढ़ी हुई चलती रोक और आंशिक लाभ समाप्ति तंत्र।
- समय-सीमा अनुकूलनः सिग्नल को कई समय-सीमाओं पर सत्यापित करना, लेनदेन की स्थिरता में सुधार करना।
संक्षेप
इस रणनीति ने गॉस चैनल फ़िल्टर और यादृच्छिक आरएसआई संकेतक के संयोजन के माध्यम से एक ट्रेडिंग सिस्टम का निर्माण किया है जिसमें एक मजबूत अनुकूलन क्षमता है। गॉस चैनल की गणितीय नींव संकेतों की चिकनाई और विश्वसनीयता की गारंटी देती है, जबकि यादृच्छिक आरएसआई का संयोजन प्रवेश समय की सटीकता को और बढ़ाता है। रणनीति का मुख्य लाभ बाजार के शोर को प्रभावी रूप से फ़िल्टर करने और रुझानों को ठीक से पकड़ने में है, लेकिन साथ ही साथ संख्यात्मक अनुकूलन और जोखिम प्रबंधन के मुद्दों पर भी ध्यान देने की आवश्यकता है।
रणनीति स्रोत कोड
/*backtest
start: 2024-02-22 00:00:00
end: 2025-02-19 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"SOL_USDT"}]
*/
//@version=5
strategy(title="Gaussian Channel Strategy v3.0", overlay=true, calc_on_every_tick=false, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, slippage=0, fill_orders_on_standard_ohlc=true)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Filter Functions (Must be declared first)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
f_filt9x(_a, _s, _i) =>
var int _m2 = 0, var int _m3 = 0, var int _m4 = 0, var int _m5 = 0, var int _m6 = 0,
var int _m7 = 0, var int _m8 = 0, var int _m9 = 0, var float _f = .0
_x = 1 - _a
_m2 := _i == 9 ? 36 : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
_m3 := _i == 9 ? 84 : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
_m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5 : _i == 4 ? 1 : 0
_m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6 : _i == 5 ? 1 : 0
_m6 := _i == 9 ? 84 : _i == 8 ? 28 : _i == 7 ? 7 : _i == 6 ? 1 : 0
_m7 := _i == 9 ? 36 : _i == 8 ? 8 : _i == 7 ? 1 : 0
_m8 := _i == 9 ? 9 : _i == 8 ? 1 : 0
_m9 := _i == 9 ? 1 : 0
_f := math.pow(_a, _i) * nz(_s) + _i * _x * nz(_f[1]) - (_i >= 2 ? _m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ? _m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ? _m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ? _m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ? _m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ? _m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ? _m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ? _m9 * math.pow(_x, 9) * nz(_f[9]) : 0)
f_pole(_a, _s, _i) =>
_f1 = f_filt9x(_a, _s, 1)
_f2 = _i >= 2 ? f_filt9x(_a, _s, 2) : 0.0
_f3 = _i >= 3 ? f_filt9x(_a, _s, 3) : 0.0
_f4 = _i >= 4 ? f_filt9x(_a, _s, 4) : 0.0
_f5 = _i >= 5 ? f_filt9x(_a, _s, 5) : 0.0
_f6 = _i >= 6 ? f_filt9x(_a, _s, 6) : 0.0
_f7 = _i >= 7 ? f_filt9x(_a, _s, 7) : 0.0
_f8 = _i >= 8 ? f_filt9x(_a, _s, 8) : 0.0
_f9 = _i == 9 ? f_filt9x(_a, _s, 9) : 0.0
_fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 : _i == 4 ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 : _i == 7 ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
[_fn, _f1]
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
int poles = input.int(4, "Poles", 1, 9, group="Gaussian Channel")
int period = input.int(144, "Sampling Period", 2, group="Gaussian Channel")
float mult = input.float(1.414, "True Range Multiplier", group="Gaussian Channel")
bool reducedLag = input.bool(false, "Reduced Lag Mode", group="Gaussian Channel")
bool fastResponse = input.bool(false, "Fast Response Mode", group="Gaussian Channel")
// Stochastic RSI
smoothK = input.int(3, "K", 1, group="Stochastic RSI")
smoothD = input.int(3, "D", 1, group="Stochastic RSI")
lengthRSI = input.int(14, "RSI Length", 1, group="Stochastic RSI")
lengthStoch = input.int(14, "Stochastic Length", 1, group="Stochastic RSI")
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Calculations
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
beta = (1 - math.cos(4*math.asin(1)/period)) / (math.pow(1.414, 2/poles) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (period - 1)/(2*poles)
src = hlc3
srcData = reducedLag ? src + (src - src[lag]) : src
trData = reducedLag ? ta.tr + (ta.tr - ta.tr[lag]) : ta.tr
[filterMain, filter1] = f_pole(alpha, srcData, poles)
[filterTRMain, filterTR1] = f_pole(alpha, trData, poles)
finalFilter = fastResponse ? (filterMain + filter1)/2 : filterMain
finalTR = fastResponse ? (filterTRMain + filterTR1)/2 : filterTRMain
hband = finalFilter + finalTR * mult
lband = finalFilter - finalTR * mult
// Stochastic RSI
rsi = ta.rsi(close, lengthRSI)
k = ta.sma(ta.stoch(rsi, rsi, rsi, lengthStoch), smoothK)
d = ta.sma(k, smoothD)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Trading Logic
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
gaussianGreen = finalFilter > finalFilter[1]
priceAbove = close > hband
stochCondition = k > 80 or k < 20
longCondition = gaussianGreen and priceAbove and stochCondition
exitCondition = ta.crossunder(close, hband)
strategy.entry("Long", strategy.long, when=longCondition)
strategy.close("Long", when=exitCondition)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Visuals
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
filterColor = finalFilter > finalFilter[1] ? #0aff68 : #ff0a5a
plot(finalFilter, "Filter", filterColor, 2)
plot(hband, "High Band", filterColor)
plot(lband, "Low Band", filterColor)
fill(plot(hband), plot(lband), color.new(filterColor, 90), "Channel Fill")