मूविंग एवरेज बाउंस रणनीति


निर्माण तिथि: 2023-12-08 16:47:39 अंत में संशोधित करें: 2023-12-08 16:47:39
कॉपी: 0 क्लिक्स: 925
1
ध्यान केंद्रित करना
1621
समर्थक

मूविंग एवरेज बाउंस रणनीति

रणनीति अवलोकन

एक चलती औसत रिबाउंड रणनीति एक ऐसी रणनीति है जो चलती औसत को तोड़ने के लिए कीमतों को ट्रैक करती है। यह जांचता है कि क्या स्टैम्प चलती औसत के नीचे से वापस उछाल देता है, यदि ऐसा है, तो यह एक बहुमुखी संकेत है; यदि स्टैम्प चलती औसत से ऊपर की दिशा में उछाल देता है, तो यह एक खाली सिर संकेत है।

नीति का नाम

Exponential Moving Average Bounce Strategy

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

यह रणनीति एक्सपोनेंशियल मूविंग एवरेज पर आधारित है। यह वास्तविक समय में एक ईएमए लाइन की गणना करता है। फिर यह जांचता है कि क्या कीमत ईएमए लाइन के ऊपर या नीचे से उछाल देती हैः

  • यदि कीमत ईएमए से नीचे गिरती है और फिर ईएमए से ऊपर उठती है, तो यह एक मल्टीहेड सिग्नल है
  • यदि कीमत पहले ईएमए लाइन को तोड़ती है और फिर ईएमए लाइन के नीचे बंद होने के लिए वापस गिरती है, तो यह एक खाली सिर संकेत है

इस तरह की प्रतिक्रिया रणनीति के लिए एक प्रवेश संकेत है।

रणनीति का विश्लेषण

इस तरह से, आप अपने आप को पकड़ने से बच सकते हैं

ईएमए रिबाउंड रणनीति केवल कीमतों के उलट होने की पुष्टि करने के बाद ही प्रवेश करती है, जिससे प्रतिगामी संचालन को रोकने में मदद मिलती है।

यह एक ऐतिहासिक लाभ है।

सूचकांक चलती औसत के उपयोग के कारण, यह प्रभावी रूप से मूल्य डेटा को चिकना करने और बाजार के शोर को फ़िल्टर करने में सक्षम है, जिससे रणनीति में कम वापसी होती है और ऐतिहासिक लाभ बेहतर होता है।

आसान समझ, पैरामीटर समायोजन के लिए लचीला

ईएमए पुनरावृत्ति रणनीति केवल चलती औसत पर निर्भर करती है, यह बहुत सरल है और शुरुआती लोगों के लिए आसान है; और ईएमए चक्र पैरामीटर को विभिन्न किस्मों के लिए लचीलापन से समायोजित किया जा सकता है।

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

झूठे संकेत

ईएमए लाइन के पास अक्सर घने झूठे ब्रेक होते हैं, जो गलत सिग्नल का कारण बन सकते हैं। इन शोरों को फ़िल्टर करने के लिए ईएमए पैरामीटर को समायोजित करने की आवश्यकता होती है।

गतिशीलता, कोई मोड़ नहीं

यह रणनीति मूल रूप से एक अनुक्रमिक संचालन है। कीमत के मोड़ की भविष्यवाणी नहीं की जा सकती है, केवल प्रवृत्ति का पीछा किया जा सकता है। यह सबसे अच्छा प्रवेश समय है जो एक चक्रीय समायोजन को याद कर सकता है।

स्टॉप क्षतिग्रस्त स्थिति को आसानी से तोड़ दिया जाता है

चलती औसत के पास के स्टॉप लेवल को कभी-कभी तोड़ दिया जाता है, जिससे नुकसान बढ़ जाता है। इसके लिए अधिक लचीले स्टॉप का उपयोग करना आवश्यक है।

अनुकूलन दिशा

फ़िल्टर सिग्नल के साथ अन्य संकेतक

अन्य संकेतकों जैसे कि आरएसआई, एमएसीडी और अन्य को शामिल किया जा सकता है ताकि कीमतों में उलटफेर की पुष्टि की जा सके और झूठे संकेतों को फ़िल्टर किया जा सके।

स्टॉप लॉस को अनुकूलित करें

समय-बंद, झटके-बंद और अन्य अधिक लचीले स्टॉप-अप का उपयोग करके, दुर्घटनाग्रस्त होने के जोखिम को कम किया जा सकता है।

पैरामीटर अनुकूलन

ईएमए चक्र के पैरामीटर को अनुकूलित करें, सबसे अच्छा पैरामीटर संयोजन ढूंढें। आप ईएमए पैरामीटर को गतिशील रूप से बदल सकते हैं, बाजार चक्र को ट्रैक कर सकते हैं।

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2022-12-01 00:00:00
end: 2023-12-07 00:00:00
period: 1d
basePeriod: 1h
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/
// © tweakerID

// Simple strategy that checks for price bounces over an Exponential Moving Average. If the CLOSE of the candle bounces
// back from having it's LOW below the EMA, then it's a Bull Bounce. If the CLOSE of the candle bounces down from having it's
// high above the EMA, then it's a Bear Bounce. This logic can be reverted.

//@version=4
strategy("EMA Bounce", overlay=true, 
     default_qty_type=strategy.percent_of_equity, 
     default_qty_value=100, 
     initial_capital=10000, 
     commission_value=0.04, 
     calc_on_every_tick=false, 
     slippage=0)

direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))

/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")  

i_EMA=input(20, title="EMA Length")

/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")  

// Backtester General Inputs
i_SL=input(true, title="Use Swing Stop Loss and Take Profit")
i_SPL=input(defval=10, title="Swing Point Loopback")
i_PercIncrement=input(defval=.2, step=.1, title="Swing Point SL Perc Increment")*0.01
i_TPRRR = input(1.2, step=.1, title="Take Profit Risk Reward Ratio")

// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1] 
 or strategy.position_size < strategy.position_size[1]

// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na 
entry_HH_price = strategy.position_size < 0 ? HH_price : na 
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR


/////////////////////// STRATEGY LOGIC /////////////////////////////////////////

EMA=ema(close, i_EMA)
LowAboveEMA=low > EMA
LowBelowEMA=low < EMA
HighAboveEMA=high > EMA
HighBelowEMA=high < EMA
BullBounce=LowAboveEMA[1] and LowBelowEMA and close > EMA //and close > open
BearBounce=HighBelowEMA[1] and HighAboveEMA and close < EMA //and close < open
plot(EMA)

BUY=BullBounce
SELL=BearBounce

//Inputs
DPR=input(false, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")

// Entries
if reverse
    if not DPR
        strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
    else     
        strategy.entry("long", strategy.long, when=SELL)
        strategy.entry("short", strategy.short, when=BUY)
else
    if not DPR 
        strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
    else
        strategy.entry("long", strategy.long, when=BUY)
        strategy.entry("short", strategy.short, when=SELL)


SL=entry_LL_price
SSL=entry_HH_price
TP=tp
STP=stp

strategy.exit("TP & SL", "long", limit=TP, stop=SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=SSL, when=i_SL)

/////////////////////// PLOTS //////////////////////////////////////////////////

plot(strategy.position_size > 0 ? SL : na , title='SL', style=plot.style_cross, color=color.red)
plot(strategy.position_size < 0 ? SSL : na , title='SSL', style=plot.style_cross, color=color.red)
plot(strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar, 
 color=color.green, title="Bullish Setup", transp=80, size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar, 
 color=color.red, title="Bearish Setup", transp=80, size=size.auto)