जानबूझकर उलटा लिफाफा मतलब रणनीति


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

जानबूझकर उलटा लिफाफा मतलब रणनीति

अवलोकन

इरादा रिवर्स पैकेजिंग ग्रिड औसत मूल्य रणनीति एक इरादा रिवर्स ट्रेडिंग रणनीति है जो एक चलती औसत रेखा पर आधारित है। यह रणनीति द्वि-सूचक चलती औसत को आधार के रूप में गणना करती है और इसके ऊपर और नीचे कई पैकेजिंग बैंड जोड़ती है। जब कीमत पैकेजिंग बैंड को छूती है, तो दिशा के अनुसार अधिक या खाली स्थिति खोलें। जब कीमत समान रेखा पर लौटती है, तो स्थिति को बाहर निकालें।

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

इस रणनीति में द्वि-सूचक चलती औसत (डीईएमए) का उपयोग किया जाता है। द्वि-सूचक चलती औसत एक प्रकार का चलती औसत है जो मूल्य परिवर्तन के प्रति संवेदनशील है। इसके आधार पर, रणनीति एक समान रेखा के साथ एक समूह बनाती है, जिसमें ऊपर और नीचे दोनों तरफ कई मूल्य बैंड जोड़े जाते हैं। समूह का दायरा उपयोगकर्ता द्वारा निर्धारित किया जाता है, प्रत्येक मूल्य बैंड के बीच एक निश्चित प्रतिशत अंतराल के अनुसार।

जब कीमतें ऊपर की ओर बढ़ती हैं तो यह रणनीति कम हो जाती है; जब कीमतें नीचे की ओर गिरती हैं तो यह रणनीति अधिक हो जाती है। हर बार जब एक नया मूल्य क्षेत्र होता है, तो यह रणनीति बढ़ जाती है। जब कीमतें चलती औसत रेखा के पास लौटती हैं, तो यह रणनीति सभी पदों को समाप्त कर देती है।

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

रणनीतिक लाभ

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

रणनीतिक जोखिम

  • इस तरह की घटनाओं से कोई लाभ नहीं मिल रहा है।
  • अनुचित पैरामीटर सेट करने से बहुत अधिक लेनदेन हो सकता है।
  • इस प्रकार, बाजारों में उतार-चढ़ाव के लिए अपेक्षाकृत स्थिरता की आवश्यकता होती है।
  • यह बहुत छोटा है, और आप इसे खोलने में असमर्थ हो सकते हैं।

मूल्य परिवर्तनों को ट्रिगर करने के लिए संवेदनशीलता को बढ़ाकर, पैकेजिंग नेटवर्क क्षेत्र को उचित रूप से ढीला करके जोखिम को कम किया जा सकता है। साथ ही, विभिन्न चक्रों के लिए चलती औसत रेखा की लंबाई को समायोजित किया जा सकता है।

रणनीति अनुकूलन दिशा

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

  1. चलती औसत रेखा एल्गोरिदम का अनुकूलन। विभिन्न प्रकार के चलती औसत रेखा संकेतकों के प्रभाव का परीक्षण किया जा सकता है।

  2. औसत रेखा लंबाई पैरामीटर को समायोजित करें. चक्र को छोटा करने से अल्पकालिक मूल्य परिवर्तनों को पकड़ने में सुधार हो सकता है, लेकिन यह शोर ट्रेडिंग को भी बढ़ा सकता है।

  3. इष्टतम पैकेजिंग क्षेत्र मापदंडों को अनुकूलित करें। आप विभिन्न प्रतिशत सेटिंग्स का परीक्षण कर सकते हैं और सबसे अच्छा मापदंड संयोजन पा सकते हैं।

  4. बढ़ी हुई हानि की रणनीति। एक चलती रोक या एक वापसी रोक स्थापित करें, जिससे एकल नुकसान को प्रभावी ढंग से नियंत्रित किया जा सके।

  5. फ़िल्टरिंग की शर्तें बढ़ाएं। अन्य संकेतकों के संकेतों के साथ संयोजन में, अनुचित व्यवहार के तहत स्थिति को निष्क्रिय करने से बचें।

संक्षेप

इरादा रिवर्स संवितरण नेटवर्क औसत मूल्य रणनीति औसत रेखा मूल्य चैनल का निर्माण करके मूल्य पलटाव के अवसरों को प्रभावी ढंग से पकड़ती है। यह विभिन्न बाजार स्थितियों के लिए मापदंडों को लचीले ढंग से समायोजित कर सकती है। यह रणनीति कम लेनदेन लागत और उच्च रिटर्न दर के साथ एक अनुशंसित मात्रात्मक लेनदेन रणनीति है।

रणनीति स्रोत कोड
/*backtest
start: 2022-11-27 00:00:00
end: 2023-12-03 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("Mean Reversion - Envelope Strategy", overlay=true )

// ----------------------- DESCRIPTION -----------------------
// THIS SCRIPT IS A MEAN REVERSION SYSTEM THAT USES A MOVING AVERAGE AS BASE CALCULATION AND A % OF THIS MOVING AVERAGE TO CALCULATE THE ENVELOPE
// BY DEFAULT, THE SYSTEM WILL PLACE LONG ORDERS ON THE MOVING AVERAGE -5% PER ENVELOPE COUNT (5%, 10% AND SO ON...)
// YOU CAN ENABLE THE SHORT ORDERS THAT WILL FOLLOW THE SAME LOGIC ON THE OPPOSITE SIDE
// THE SYSTEM WILL CLOSE EVERY ONGOING TRADE WHEN THE PRICE RETURNS TO THE MEAN

// ---------------------------------------------
// ---------------- SETTINGS -------------------
src = input(close, "Moving Average Source", group = "Moving Average")
ma_window = input.int(5, "Moving Average Window", step = 1, group = "Moving Average")
ma_type = input.string('4. DEMA', "Moving Average Type", options=['1. SMA', '2. EMA', '3. RMA', '4. DEMA'], group = "Moving Average")
enveloppe_step = input.float(0.05, "Delta Per Enveloppe", step = 0.01, group = "Envelope")
envelope_count = input.int(5, "Envelope count", options = [1, 2, 3, 4, 5], group = "Envelope")
use_longs = input.bool(true, 'Use Long Orders ?', group = "Orders") 
use_short = input.bool(false, 'Use Short Orders ?', group = "Orders")


// ---------------------------------------------
// -------------- INDICATORS -------------------
ma_funct() =>
    if(ma_type == '1. SMA') 
        ta.sma(src, ma_window)
    if(ma_type == '2. EMA') 
        ta.ema(src, ma_window)
    if(ma_type == '3. RMA') 
        ta.rma(src, ma_window)
    if(ma_type == '4. DEMA') 
        2 * ta.ema(src, ma_window) - ta.ema(ta.ema(src, ma_window), ma_window)

ma_base = ma_funct()

ma_high_1 = envelope_count > 0 ? ma_base * (1 + enveloppe_step) : na
ma_high_2 = envelope_count > 1 ? ma_base * (1 + enveloppe_step * 2) : na
ma_high_3 = envelope_count > 2 ? ma_base * (1 + enveloppe_step * 3) : na
ma_high_4 = envelope_count > 3 ? ma_base * (1 + enveloppe_step * 4) : na
ma_high_5 = envelope_count > 4 ? ma_base * (1 + enveloppe_step * 5) : na

ma_low_1 = envelope_count > 0 ? ma_base * (1 - enveloppe_step) : na
ma_low_2 = envelope_count > 0 ? ma_base * (1 - enveloppe_step * 2) : na
ma_low_3 = envelope_count > 0 ? ma_base * (1 - enveloppe_step * 3) : na
ma_low_4 = envelope_count > 0 ? ma_base * (1 - enveloppe_step * 4) : na
ma_low_5 = envelope_count > 0 ? ma_base * (1 - enveloppe_step * 5) : na


// ---------------------------------------------
// --------------- STRATEGY --------------------
if use_longs
    if envelope_count > 0 and strategy.opentrades < 1
        strategy.entry('long 1', strategy.long, limit=ma_low_1, qty=(strategy.equity / ma_low_1) * (1 / envelope_count))
    if envelope_count > 1 and strategy.opentrades < 2
        strategy.entry('long 2', strategy.long, limit=ma_low_2, qty=(strategy.equity / ma_low_2) * (1 / envelope_count))
    if envelope_count > 2 and strategy.opentrades < 3
        strategy.entry('long 3', strategy.long, limit=ma_low_3, qty=(strategy.equity / ma_low_3) * (1 / envelope_count))
    if envelope_count > 3 and strategy.opentrades < 4
        strategy.entry('long 4', strategy.long, limit=ma_low_4, qty=(strategy.equity / ma_low_4) * (1 / envelope_count))
    if envelope_count > 4 and strategy.opentrades < 5
        strategy.entry('long 5', strategy.long, limit=ma_low_5, qty=(strategy.equity / ma_low_5) * (1 / envelope_count))


if use_short
    if envelope_count > 0 and strategy.opentrades < 1
        strategy.entry('short 1', strategy.short, limit=ma_high_1, qty=(strategy.equity / ma_high_1) * (1 / envelope_count))
    if envelope_count > 1 and strategy.opentrades < 2
        strategy.entry('short 2', strategy.short, limit=ma_high_2, qty=(strategy.equity / ma_high_2) * (1 / envelope_count))
    if envelope_count > 2 and strategy.opentrades < 3
        strategy.entry('short 3', strategy.short, limit=ma_high_3, qty=(strategy.equity / ma_high_3) * (1 / envelope_count))
    if envelope_count > 3 and strategy.opentrades < 4
        strategy.entry('short 4', strategy.short, limit=ma_high_4, qty=(strategy.equity / ma_high_4) * (1 / envelope_count))
    if envelope_count > 4 and strategy.opentrades < 5
        strategy.entry('short 5', strategy.short, limit=ma_high_5, qty=(strategy.equity / ma_high_5) * (1 / envelope_count))

strategy.exit('close', limit=ma_base)


// ---------------------------------------------
// ------------------ PLOT ---------------------
ma_base_plot = plot(ma_base, title = "Base MA", color = color.orange, linewidth = 3, offset = 1)

ma_high_1_plot = plot(ma_high_1, title = "MA high 1", color = color.red, offset = 1)
ma_high_2_plot = plot(ma_high_2, title = "MA high 2", color = color.red, offset = 1)
ma_high_3_plot = plot(ma_high_3, title = "MA high 3", color = color.red, offset = 1)
ma_high_4_plot = plot(ma_high_4, title = "MA high 4", color = color.red, offset = 1)
ma_high_5_plot = plot(ma_high_5, title = "MA high 5", color = color.red, offset = 1)

ma_low_1_plot = plot(ma_low_1, title = "MA low 1", color = color.green, offset = 1)
ma_low_2_plot = plot(ma_low_2, title = "MA low 2", color = color.green, offset = 1)
ma_low_3_plot = plot(ma_low_3, title = "MA low 3", color = color.green, offset = 1)
ma_low_4_plot = plot(ma_low_4, title = "MA low 4", color = color.green, offset = 1)
ma_low_5_plot = plot(ma_low_5, title = "MA low 5", color = color.green, offset = 1)