वॉल स्ट्रीट माउस हेलो इंडिकेटर पर आधारित क्रिप्टोकरेंसी की तेजी और मंदी की रणनीति


निर्माण तिथि: 2023-11-01 11:27:20 अंत में संशोधित करें: 2023-11-01 11:27:20
कॉपी: 0 क्लिक्स: 681
1
ध्यान केंद्रित करना
1617
समर्थक

वॉल स्ट्रीट माउस हेलो इंडिकेटर पर आधारित क्रिप्टोकरेंसी की तेजी और मंदी की रणनीति

अवलोकन

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

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

  1. वॉल स्ट्रीट माउस कैचर ग्लोब इंडिकेटर औसत रेखा की गणना करें, औसत रेखा की लंबाई 200 चक्रों पर सेट करें।

  2. औसत रेखा के गिरने की स्थिति का न्याय करेंः जब औसत रेखा ऊपर जाती है, तो रणनीति एक bullish ऑपरेशन करती है; जब औसत रेखा नीचे जाती है, तो रणनीति एक bearish ऑपरेशन करती है।

  3. रणनीतियाँ जो स्वचालित रूप से स्थिति खोलने और स्थिति में सुधार करने के लिए उपयोग की जाती हैं, औसत रेखा के नीचे और नीचे की स्थिति और वर्तमान स्थिति के आधार परः

    • जब औसत रेखा ऊंची होती है और वर्तमान में कोई स्थिति नहीं होती है, तो रणनीतिक बाजार मूल्य स्वचालित रूप से अधिक स्थिति खोलता है;

    • जब औसत नीचे जाता है और वर्तमान में कोई स्थिति नहीं है, तो रणनीतिक बाजार मूल्य स्वचालित रूप से एक शून्य स्थिति खोलता है;

    • रणनीति बाजार मूल्य स्वचालित रूप से समतल हो जाता है जब बहु-ऑर्डर लाभ सेट स्टॉप अनुपात तक पहुंचता है;

    • जब घाटा स्थिति का लाभ सेट स्टॉप अनुपात तक पहुंचता है, तो रणनीति बाजार मूल्य स्वचालित रूप से घाटा आदेश को समतल कर देता है;

    • जब एक दीर्घावधि हानि सेट स्टॉप लॉस अनुपात तक पहुंचती है, तो रणनीति बाजार मूल्य स्वचालित रूप से दीर्घावधि के लिए सपाट हो जाता है;

    • जब घाटे की स्थिति का घाटा सेट स्टॉप लॉस अनुपात तक पहुंचता है, तो रणनीति बाजार मूल्य स्वचालित रूप से घाटे के आदेश को समाप्त कर देता है।

  4. रणनीति बेंचमार्क क्रिप्टोकरेंसी बाजार में बदलाव के आधार पर वास्तविक समय में स्टॉप-स्टॉप-लॉस कीमतों को अपडेट करना।

श्रेष्ठता विश्लेषण

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

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

  3. स्टॉप-स्टॉप-लॉस को शामिल करने की रणनीति, प्रवृत्ति को पकड़ने और गिरावट को रोकने के लिए, और व्यक्तिगत नुकसान को नियंत्रित करने के लिए।

  4. रणनीति पूरी तरह से स्वचालित है, इसमें कोई मानवीय हस्तक्षेप नहीं है और यह 24 घंटे चलती है।

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

  1. कुछ क्रिप्टोक्यूरेंसी की कीमतों में बेसिक क्रिप्टोक्यूरेंसी से विचलन की संभावना है, जिससे रणनीति को सामान्य रूप से व्यापार करने में असमर्थ होने का जोखिम होता है। बेसिक क्रिप्टोक्यूरेंसी को चुनने के लिए कई बेसिक क्रिप्टोकरेंसी की गणना के लिए प्रासंगिक कारक को अनुकूलित किया जा सकता है।

  2. बाजार में असामान्य उतार-चढ़ाव के कारण स्टॉप-आउट का जोखिम मौजूद है. स्टॉप-आउट अनुपात को उचित रूप से समायोजित किया जा सकता है या स्टॉप-आउट ट्रैकिंग में शामिल किया जा सकता है.

  3. रुकावट अनुपात को बहुत छोटा सेट करने का जोखिम है, जिससे पर्याप्त प्रवृत्ति लाभ नहीं मिल सकता है। रुझान ट्रैकिंग या गतिशील रुकावट को जोड़ा जा सकता है।

  4. एक झूठी तोड़फोड़ के जोखिम के कारण स्थिति बंद हो जाती है। सूचकांक मापदंडों, पहचान सेटिंग्स या फिर से प्रवेश तंत्र को ठीक से समायोजित किया जा सकता है।

अनुकूलन दिशा

  1. सम्बद्धता विश्लेषण का उपयोग करके कई बेंचमार्क क्रिप्टोकरेंसी का चयन करें, सूचकांकों की गणना करें, एकल बेंचमार्क मुद्रा जोखिम को कम करें।

  2. रुझान ट्रैकिंग तंत्र को जोड़ना और स्टॉप-लॉस को उतार-चढ़ाव के आधार पर गतिशील रूप से समायोजित करना।

  3. चरम सीमाओं को तोड़ने से रोकने के लिए क्षति के स्तर को बढ़ाएं

  4. एक और प्रवेश प्रक्रिया जो नुकसान को रोकने के बाद अनुवर्ती प्रक्रियाओं को याद करने से बचाएगी।

  5. संकेतक मापदंडों को अनुकूलित करें, पहचान सेटिंग्स, संकेतक प्रभाव में सुधार करें

  6. विभिन्न क्रिप्टोकरेंसी के लिए अनुकूलित पैरामीटर, रणनीति अनुकूलन को बढ़ावा देना।

  7. पोजीशन मैनेजमेंट को अनुकूलित करें, पूंजी के आकार के अनुसार पोजीशन को गतिशील रूप से समायोजित करें।

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2022-10-25 00:00:00
end: 2023-10-31 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/
// © levieux

//@version=5
strategy(title='Correlation Strategy', shorttitle='Correlation Strategy', initial_capital=1000, overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1)

supportLength = input.int(200, minval=1, title='Support Length')
supportSymbol = input('BTC_USDT:swap', title='Correlated Symbol')
supportSource = input(hlc3, title='Price Source')
takeprofitLong = input.float(0.2, 'Take Profit Long', step=0.01)
takeprofitShort = input.float(0.15, 'Take Profit Short', step=0.01)
stoplossLong = input.float(0.1, 'Stop Loss Long', step=0.01)
stoplossShort = input.float(0.04, 'Stop Loss Short', step=0.01)
start = input(defval = timestamp("01 Jan 2016 00:00 +0000"), title = "Start Time")
end = input(defval = timestamp("31 Dec 2050 23:59 +0000"), title = "End Time")

supportTicker = request.security(supportSymbol, timeframe.period, supportSource, lookahead=barmerge.lookahead_off)  //input(close, title="Source")
supportLine = ta.wma(supportTicker, supportLength)

window() => true

if not window()
    strategy.cancel_all()

supportLongPrice = close
supportShortPrice = close

if strategy.position_size > 0
    supportLongPrice := supportLongPrice[1]
if strategy.position_size < 0
    supportShortPrice := supportShortPrice[1]

longCondition = ta.rising(supportLine, 5) and window() and strategy.position_size <= 0
shortCondition = ta.falling(supportLine, 5) and window() and window() and strategy.position_size > 0
takeprofitLongCondition = takeprofitLong > 0 and window() and strategy.position_size > 0 and supportTicker > supportLongPrice * (1 + takeprofitLong)
stoplossLongCondition = stoplossLong > 0 and window() and strategy.position_size > 0 and supportTicker < supportLongPrice * (1 - stoplossLong)
takeprofitShortCondition = takeprofitShort > 0 and window() and strategy.position_size < 0 and supportTicker > supportShortPrice * (1 + takeprofitShort)
stoplossShortCondition = stoplossShort > 0 and window() and strategy.position_size < 0 and supportTicker < supportShortPrice * (1 - stoplossShort)

if longCondition
    strategy.entry('Long', strategy.long)
    supportLongPrice := supportTicker

if shortCondition
    strategy.entry('Short', strategy.short)
    supportShortPrice := supportTicker

if takeprofitLongCondition
    strategy.close('Long')
if stoplossLongCondition
    strategy.close('Long')
if takeprofitShortCondition
    strategy.close('Short')
if stoplossShortCondition
    strategy.close('Short')

///////////////////
// MONTHLY TABLE //

new_month = month(time) != month(time[1])
new_year  = year(time)  != year(time[1])

eq = strategy.equity

bar_pnl = eq / eq[1] - 1
bar_bh = (close-close[1])/close[1]

cur_month_pnl = 0.0
cur_year_pnl  = 0.0
cur_month_bh = 0.0
cur_year_bh  = 0.0

// Current Monthly P&L
cur_month_pnl := new_month ? 0.0 : 
                 (1 + cur_month_pnl[1]) * (1 + bar_pnl) - 1 
cur_month_bh := new_month ? 0.0 : 
                 (1 + cur_month_bh[1]) * (1 + bar_bh) - 1

// Current Yearly P&L
cur_year_pnl := new_year ? 0.0 : 
                 (1 + cur_year_pnl[1]) * (1 + bar_pnl) - 1
cur_year_bh := new_year ? 0.0 : 
                 (1 + cur_year_bh[1]) * (1 + bar_bh) - 1

// Arrays to store Yearly and Monthly P&Ls
var month_pnl  = array.new_float(0)
var month_time = array.new_int(0)
var month_bh  = array.new_float(0)

var year_pnl  = array.new_float(0)
var year_time = array.new_int(0)
var year_bh  = array.new_float(0)

end_time = false

end_time:= time_close + (time_close - time_close[1]) > timenow or barstate.islastconfirmedhistory

if (not na(cur_month_pnl[1]) and (new_month or end_time))
    if (end_time[1])
        array.pop(month_pnl)
        array.pop(month_time)
        
    array.push(month_pnl , cur_month_pnl[1])
    array.push(month_time, time[1])
    array.push(month_bh , cur_month_bh[1])

if (not na(cur_year_pnl[1]) and (new_year or end_time))
    if (end_time[1])
        array.pop(year_pnl)
        array.pop(year_time)
        
    array.push(year_pnl , cur_year_pnl[1])
    array.push(year_time, time[1])
    array.push(year_bh , cur_year_bh[1])

// Monthly P&L Table    
var monthly_table = table(na)

getCellColor(pnl, bh)  => 
    if pnl > 0
        if bh < 0 or pnl > 2 * bh
            color.new(color.green, transp = 20)
        else if pnl > bh
            color.new(color.green, transp = 50)
        else
            color.new(color.green, transp = 80)
    else
        if bh > 0 or pnl < 2 * bh
            color.new(color.red, transp = 20)
        else if pnl < bh
            color.new(color.red, transp = 50)
        else
            color.new(color.red, transp = 80)

if end_time
    monthly_table := table.new(position.bottom_right, columns = 14, rows = array.size(year_pnl) + 1, border_width = 1)

    table.cell(monthly_table, 0,  0, "",     bgcolor = #cccccc)
    table.cell(monthly_table, 1,  0, "Jan",  bgcolor = #cccccc)
    table.cell(monthly_table, 2,  0, "Feb",  bgcolor = #cccccc)
    table.cell(monthly_table, 3,  0, "Mar",  bgcolor = #cccccc)
    table.cell(monthly_table, 4,  0, "Apr",  bgcolor = #cccccc)
    table.cell(monthly_table, 5,  0, "May",  bgcolor = #cccccc)
    table.cell(monthly_table, 6,  0, "Jun",  bgcolor = #cccccc)
    table.cell(monthly_table, 7,  0, "Jul",  bgcolor = #cccccc)
    table.cell(monthly_table, 8,  0, "Aug",  bgcolor = #cccccc)
    table.cell(monthly_table, 9,  0, "Sep",  bgcolor = #cccccc)
    table.cell(monthly_table, 10, 0, "Oct",  bgcolor = #cccccc)
    table.cell(monthly_table, 11, 0, "Nov",  bgcolor = #cccccc)
    table.cell(monthly_table, 12, 0, "Dec",  bgcolor = #cccccc)
    table.cell(monthly_table, 13, 0, "Year", bgcolor = #999999)


    for yi = 0 to array.size(year_pnl) - 1
        table.cell(monthly_table, 0,  yi + 1, str.tostring(year(array.get(year_time, yi))), bgcolor = #cccccc)
        
        y_color = getCellColor(array.get(year_pnl, yi), array.get(year_bh, yi))
        table.cell(monthly_table, 13, yi + 1, str.tostring(math.round(array.get(year_pnl, yi) * 100)) + " (" + str.tostring(math.round(array.get(year_bh, yi) * 100)) + ")", bgcolor = y_color)
        
    for mi = 0 to array.size(month_time) - 1
        m_row   = year(array.get(month_time, mi))  - year(array.get(year_time, 0)) + 1
        m_col   = month(array.get(month_time, mi)) 
        m_color = getCellColor(array.get(month_pnl, mi), array.get(month_bh, mi))
        
        table.cell(monthly_table, m_col, m_row, str.tostring(math.round(array.get(month_pnl, mi) * 100)) + " (" + str.tostring(math.round(array.get(month_bh, mi) * 100)) +")", bgcolor = m_color)