संसाधन लोड हो रहा है... लोड करना...

jma + dwma मल्टीग्रेन द्वारा

लेखक:चाओझांग, दिनांकः 2022-05-08 17:00:47
टैगःडब्ल्यूएमए

इस क्रॉसओवर प्रणाली को मूल रूप से ज्यूरिक रिसर्च द्वारा अवधारणाबद्ध किया गया था और उनकी वेबसाइट पर दुनिया के लिए सार्वजनिक किया गया था।

संकेतक में तेजी से जुरिक मूविंग एवरेज (जेएमए) और धीमी डबल वेटेड मूविंग एवरेज (डीडब्ल्यूएमए) शामिल हैं। जब जेएमए लाइन डीडब्ल्यूएमए लाइन के ऊपर पार करती है (जो प्रवृत्ति में संभावित उलटफेर का संकेत देती है) तो एक लंबा संकेत दिखाया जाता है। जब जेएमए लाइन डीडब्ल्यूएमए लाइन के नीचे पार करती है तो एक छोटा संकेत दिखाया जाता है। जब जेएमए लाइन दिशाओं को उलट देती है तो लाभ लेने के संकेत दिखाए जाते हैं। संकेतों के लिए अलर्ट इस संकेतक में शामिल हैं।

डिफ़ॉल्ट सेटिंग्स किसी भी समय सीमा के लिए अनुकूलित नहीं हैं. दोनों JMA और DWMA लाइनें डिफ़ॉल्ट रूप से छिपी हुई हैं.

ज्यूरिक मूविंग एवरेज को पाइनस्क्रिप्ट में फिर से बनाने के लिए @everget को श्रेय।

बैकटेस्ट

/*backtest
start: 2022-04-07 00:00:00
end: 2022-05-06 23:59: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/
// © multigrain
// @version=5

indicator('jma + dwma by multigrain', 'jma + dwma', overlay=true)

//NAME            TYPE               DEFVAL     TITLE               MIN     MAX         GROUP       
longs           = input.bool        (true,      'Enable longs?')
shorts          = input.bool        (true,     'Enable shorts?')

jmaSrc          = input.source      (close,     'JMA Source',                           group='JMA')
jmaLen          = input.int         (7,         'JMA Length',       0,      100,        group='JMA')
jmaPhs          = input.int         (50,        'JMA Phase',        -100,   100,        group='JMA')
jmaPwr          = input.float       (1,         'JMA Power',        0.1,                group='JMA')

dwmaSrc         = input.source      (close,     'DWMA Source',                          group='DWMA')
dwmaLen         = input.int         (10,        'DWMA Length',      1,      100,        group='DWMA')

// Jurik Moving Average
f_jma(_src, _length, _phase, _power) =>
    phaseRatio  = _phase < -100 ? 0.5 : _phase > 100 ? 2.5 : _phase / 100 + 1.5
    beta        = 0.45 * (_length - 1) / (0.45 * (_length - 1) + 2)
    alpha       = math.pow(beta, _power)
    jma         = 0.0
    e0          = 0.0
    e0          := (1 - alpha) * _src + alpha * nz(e0[1])
    e1          = 0.0
    e1          := (_src - e0) * (1 - beta) + beta * nz(e1[1])
    e2          = 0.0
    e2          := (e0 + phaseRatio * e1 - nz(jma[1])) * math.pow(1 - alpha, 2) + math.pow(alpha, 2) * nz(e2[1])
    jma         := e2 + nz(jma[1])
    jma

// Double Weighted Moving Average
f_dwma(_src, _length) =>
    ta.wma(ta.wma(_src, _length), _length)


// Calculations
jma             = f_jma             (jmaSrc,    jmaLen,     jmaPhs,     jmaPwr)
dwma            = f_dwma            (dwmaSrc,   dwmaLen)
long            = ta.crossover      (jma,       dwma) 
long_tp         = ta.pivothigh      (jma,       1,          1)              and jma > dwma
short_tp        = ta.pivotlow       (jma,       1,          1)              and jma < dwma
short           = ta.crossunder     (jma,       dwma)
if longs
    strategy.entry("Buy", strategy.long, when=long)
    strategy.close("Buy", when=long_tp)
if shorts
    strategy.entry("Sell", strategy.short, when=short)
    strategy.close("Sell", when=short_tp)

संबंधित

अधिक

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