दो-तरफ़ा झटका सफलता रणनीति


निर्माण तिथि: 2024-01-30 17:40:05 अंत में संशोधित करें: 2024-01-30 17:40:05
कॉपी: 2 क्लिक्स: 589
1
ध्यान केंद्रित करना
1617
समर्थक

दो-तरफ़ा झटका सफलता रणनीति

अवलोकन

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

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

इस रणनीति का मुख्य तर्क द्वि-दिशात्मक मूल्य के महत्वपूर्ण बिंदुओं पर आधारित है। विशेष रूप से, निम्नलिखित कदम हैंः

  1. निर्दिष्ट अवधि के लिए पिवट उच्च और निम्न की गणना करें। यहाँ ta.pivothigh () और ta.pivotlow () फ़ंक्शंस का उपयोग किया जाता है, जो हाल के 2 दिनों के उच्चतम मूल्य को उच्च और हाल के 1 दिन के निम्नतम मूल्य को निम्न मान के रूप में गणना करता है।

  2. जब कीमत ऊपर की गणना की गई महत्वपूर्ण ऊंचाई को तोड़ती है, तो अधिक प्रविष्टि करें। जब कीमत महत्वपूर्ण निचले स्तर को तोड़ती है, तो शून्य प्रविष्टि करें।

  3. स्टॉप लॉस का उपयोग करना। स्टॉप लॉस का उपयोग करना। स्टॉप लॉस उच्चतम बिंदु + न्यूनतम मूल्य परिवर्तन की इकाइयों के रूप में किया जाता है; स्टॉप लॉस कम से कम मूल्य परिवर्तन की इकाइयों के रूप में किया जाता है।

  4. इस तरह की जानकारी के साथ, आप अपने जीवन में एक महत्वपूर्ण घटना को चित्रित कर सकते हैं।

इस प्रकार, जब कीमतों में उतार-चढ़ाव होता है, तो महत्वपूर्ण बिंदुओं के समय समय पर प्रवेश किया जा सकता है, और जल्दी से बंद हो जाता है, जिससे लाभ होता है। जब कीमतें लगातार नई ऊंचाइयों या नई कमियों को तोड़ती हैं, तो रणनीति कई बार संचयी लाभ प्राप्त कर सकती है।

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

इस तरह के दो-तरफा कदमों के कुछ प्रमुख फायदे हैं:

  1. सरल, समझने में आसान और लागू करने में आसान। यह रणनीति केवल पिवोट ऊंचाई और निचले बिंदुओं को तोड़ने पर निर्भर करती है। यह बहुत सरल है।

  2. रोकना आसान है। अधिक और कम करने के लिए, उच्च और निम्न + न्यूनतम परिवर्तन दूरी के रूप में रोकना, तेजी से रोकना और जोखिम को प्रभावी ढंग से नियंत्रित करना।

  3. दोनों दिशाओं में कार्य करने में सक्षम। चाहे बाजार में उतार-चढ़ाव हो या नहीं, यह रणनीति चलती रहती है और लाभ अर्जित करती है।

  4. अस्थिर स्थिति के लिए उपयुक्त। जब कीमतें अक्सर ऊपर और नीचे जाती हैं, तो रणनीति अक्सर लाभ के लिए मैदान में प्रवेश कर सकती है।

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

इस रणनीति के फायदे के बावजूद, कुछ जोखिमों के बारे में पता होना चाहिएः

  1. महत्वपूर्ण बिंदुओं को गलत तरीके से निर्धारित करने से घाटे में वृद्धि हो सकती है। यदि महत्वपूर्ण उच्च और निम्न बिंदुओं को गलत तरीके से निर्धारित किया जाता है, तो चरम स्थितियों में, उच्च और निम्न को मारना संभव है।

  2. जब कीमतें एकतरफा टूटने लगती हैं, तो यह रणनीति लाभदायक नहीं होती है।

  3. एक ब्रेकआउट एक अल्पकालिक नकली ब्रेकआउट हो सकता है। यह भी संभव है कि एक नकली ब्रेकआउट एक अल्पकालिक अवधि में हो, जिससे रणनीति गलत ट्रेडों का कारण बनती है।

कुल मिलाकर, यह रणनीति आघात के दौरान उपयोग के लिए अधिक उपयुक्त है। निवेशकों को प्रवृत्ति के दौरान इस रणनीति का उपयोग करने से बचने के लिए सावधानी बरतने की आवश्यकता है। साथ ही, महत्वपूर्ण बिंदुओं की गलत पहचान, झूठी तोड़फोड़ आदि के कारण होने वाले नुकसान से बचने के लिए सावधानी बरतनी चाहिए।

अनुकूलन दिशा

उपरोक्त जोखिमों को ध्यान में रखते हुए, इस रणनीति के लिए अनुकूलन के लिए जगह मुख्य रूप से निम्नलिखित क्षेत्रों में हैः

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

  2. प्रवृत्ति निर्णय के संयोजन में. रणनीति के आधार पर प्रवृत्ति के निर्णय के तर्क को जोड़ें, इस रणनीति का उपयोग अस्थिरता में करें, एकतरफा प्रवृत्ति में रणनीति को बंद करें, जिससे नुकसान कम हो।

  3. बढ़ी हुई हानि की रणनीति। जोखिम को और अधिक नियंत्रित करने के लिए, अधिक परिष्कृत हानि की रणनीति, जैसे कि चलती हानि, अंतराल तोड़ने वाली हानि आदि को डिज़ाइन किया जा सकता है।

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy('Monthly Returns with Benchmark', overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=25, commission_type=strategy.commission.percent, commission_value=0.1)

////////////
// Inputs //

// Pivot points inputs
leftBars   = input(2, group = "Pivot Points")
rightBars  = input(1, group = "Pivot Points")

// Styling inputs
prec       = input(2, title='Return Precision',                            group = "Monthly Table")
from_date  = input(timestamp("01 Jan 2000 00:00 +0000"), "From Date", group = "Monthly Table")
prof_color = input.color(color.green, title = "Gradient Colors", group = "Monthly Table", inline = "colors")
loss_color = input.color(color.red,   title = "",                group = "Monthly Table", inline = "colors")

// Benchmark inputs
use_cur    = input.bool(true,        title = "Use current Symbol for Benchmark", group = "Benchmark")
symb_bench = input('BTC_USDT:swap', title = "Benchmark",                        group = "Benchmark")
disp_bench = input.bool(true,        title = "Display Benchmark?",               group = "Benchmark")
disp_alpha = input.bool(true,        title = "Display Alpha?",                   group = "Benchmark")

// Pivot Points Strategy
swh = ta.pivothigh(leftBars, rightBars)
swl = ta.pivotlow(leftBars, rightBars)

hprice = 0.0
hprice := not na(swh) ? swh : hprice[1]

lprice = 0.0
lprice := not na(swl) ? swl : lprice[1]

le = false
le := not na(swh) ? true : le[1] and high > hprice ? false : le[1]

se = false
se := not na(swl) ? true : se[1] and low < lprice ? false : se[1]

if le
    strategy.entry('PivRevLE', strategy.long, comment='PivRevLE', stop=hprice + syminfo.mintick)

if se
    strategy.entry('PivRevSE', strategy.short, comment='PivRevSE', stop=lprice - syminfo.mintick)

plot(hprice, color=color.new(color.green, 0), linewidth=2)
plot(lprice, color=color.new(color.red, 0), linewidth=2)

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

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

eq       = strategy.equity
bench_eq = close

// benchmark eq
bench_eq_htf = request.security(symb_bench, timeframe.period, close)

if (not use_cur)
    bench_eq := bench_eq_htf

bar_pnl   = eq / eq[1] - 1
bench_pnl = bench_eq / bench_eq[1] - 1

cur_month_pnl = 0.0
cur_year_pnl  = 0.0

// Current Monthly P&L
cur_month_pnl := bar_index == 0 ? 0 : 
                 time >= from_date and (time[1] < from_date or new_month) ? bar_pnl : 
                 (1 + cur_month_pnl[1]) * (1 + bar_pnl) - 1

// Current Yearly P&L
cur_year_pnl  := bar_index == 0 ? 0 : 
                 time >= from_date and (time[1] < from_date or new_year) ? bar_pnl : 
                 (1 + cur_year_pnl[1]) * (1 + bar_pnl) - 1

bench_cur_month_pnl = 0.0
bench_cur_year_pnl  = 0.0

// Current Monthly P&L - Bench
bench_cur_month_pnl := bar_index == 0 or (time[1] < from_date and time >= from_date) ? 0 : 
                       time >= from_date and new_month ? bench_pnl : 
                       (1 + bench_cur_month_pnl[1]) * (1 + bench_pnl) - 1 

// Current Yearly P&L - Bench
bench_cur_year_pnl :=  bar_index == 0 ? 0 : 
                       time >= from_date and (time[1] < from_date  or new_year) ? bench_pnl : 
                       (1 + bench_cur_year_pnl[1]) * (1 + bench_pnl) - 1

var month_time = array.new_int(0)
var year_time  = array.new_int(0)

var month_pnl = array.new_float(0)
var year_pnl  = array.new_float(0)

var bench_month_pnl = array.new_float(0)
var bench_year_pnl  = array.new_float(0)

// Filling monthly / yearly pnl arrays
if array.size(month_time) > 0
    if month(time) == month(array.get(month_time, array.size(month_time) - 1))
        array.pop(month_pnl)
        array.pop(bench_month_pnl)
        array.pop(month_time)

if array.size(year_time) > 0
    if year(time) == year(array.get(year_time, array.size(year_time) - 1))
        array.pop(year_pnl)
        array.pop(bench_year_pnl)
        array.pop(year_time)

if (time >= from_date)
    array.push(month_time, time)
    array.push(year_time,  time)
    
    array.push(month_pnl, cur_month_pnl)
    array.push(year_pnl,  cur_year_pnl)
    
    array.push(bench_year_pnl,  bench_cur_year_pnl)
    array.push(bench_month_pnl, bench_cur_month_pnl)

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

if array.size(year_pnl) > 0 and barstate.islastconfirmedhistory

    monthly_table := table.new(position.bottom_right, columns=15, rows=array.size(year_pnl) * 3 + 5, border_width=1)

    // Fill monthly performance

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

    max_abs_y = math.max(math.abs(array.max(year_pnl)),  math.abs(array.min(year_pnl)))
    max_abs_m = math.max(math.abs(array.max(month_pnl)), math.abs(array.min(month_pnl)))

    for yi = 0 to array.size(year_pnl) - 1 by 1
        table.cell(monthly_table, 0,  yi + 1, str.tostring(year(array.get(year_time, yi))), bgcolor=#cccccc)
        table.cell(monthly_table, 13, yi + 1, ' ',   bgcolor=#999999)
        y_color = color.from_gradient(array.get(year_pnl, yi), -max_abs_y, max_abs_y, loss_color, prof_color) 
        table.cell(monthly_table, 14, yi + 1, str.tostring(math.round(array.get(year_pnl, yi) * 100, prec)), bgcolor=y_color)

    for mi = 0 to array.size(month_time) - 1 by 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 = color.from_gradient(array.get(month_pnl, mi), -max_abs_m, max_abs_m, loss_color, prof_color)

        table.cell(monthly_table, m_col, m_row, str.tostring(math.round(array.get(month_pnl, mi) * 100, prec)), bgcolor=m_color)
    
    // Fill benchmark performance
    next_row =  array.size(year_pnl) + 1  
    
    if (disp_bench)
    
        table.cell(monthly_table, 0,  next_row, 'Bench', bgcolor=#999999)
        table.cell(monthly_table, 1,  next_row, 'Jan',   bgcolor=#999999)
        table.cell(monthly_table, 2,  next_row, 'Feb',   bgcolor=#999999)
        table.cell(monthly_table, 3,  next_row, 'Mar',   bgcolor=#999999)
        table.cell(monthly_table, 4,  next_row, 'Apr',   bgcolor=#999999)
        table.cell(monthly_table, 5,  next_row, 'May',   bgcolor=#999999)
        table.cell(monthly_table, 6,  next_row, 'Jun',   bgcolor=#999999)
        table.cell(monthly_table, 7,  next_row, 'Jul',   bgcolor=#999999)
        table.cell(monthly_table, 8,  next_row, 'Aug',   bgcolor=#999999)
        table.cell(monthly_table, 9,  next_row, 'Sep',   bgcolor=#999999)
        table.cell(monthly_table, 10, next_row, 'Oct',   bgcolor=#999999)
        table.cell(monthly_table, 11, next_row, 'Nov',   bgcolor=#999999)
        table.cell(monthly_table, 12, next_row, 'Dec',   bgcolor=#999999)
        table.cell(monthly_table, 13, next_row, ' ',     bgcolor = #999999)
        table.cell(monthly_table, 14, next_row, 'Year',  bgcolor=#999999)
    
        max_bench_abs_y = math.max(math.abs(array.max(bench_year_pnl)),  math.abs(array.min(bench_year_pnl)))
        max_bench_abs_m = math.max(math.abs(array.max(bench_month_pnl)), math.abs(array.min(bench_month_pnl)))
    
        for yi = 0 to array.size(year_time) - 1 by 1
            table.cell(monthly_table, 0,  yi + 1 + next_row + 1, str.tostring(year(array.get(year_time, yi))), bgcolor=#cccccc)
            table.cell(monthly_table, 13, yi + 1 + next_row + 1, ' ',   bgcolor=#999999)
            y_color = color.from_gradient(array.get(bench_year_pnl, yi), -max_bench_abs_y, max_bench_abs_y, loss_color, prof_color)
            table.cell(monthly_table, 14, yi + 1 + next_row + 1, str.tostring(math.round(array.get(bench_year_pnl, yi) * 100, prec)), bgcolor=y_color)
     
        for mi = 0 to array.size(month_time) - 1 by 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 = color.from_gradient(array.get(bench_month_pnl, mi), -max_bench_abs_m, max_bench_abs_m, loss_color, prof_color)
    
            table.cell(monthly_table, m_col, m_row  + next_row + 1, str.tostring(math.round(array.get(bench_month_pnl, mi) * 100, prec)), bgcolor=m_color)
    
    // Fill Alpha
    if (disp_alpha)
    
        next_row :=  array.size(year_pnl) * 2 + 3   
        table.cell(monthly_table, 0,  next_row, 'Alpha', bgcolor=#999999)
        table.cell(monthly_table, 1,  next_row, 'Jan',   bgcolor=#999999)
        table.cell(monthly_table, 2,  next_row, 'Feb',   bgcolor=#999999)
        table.cell(monthly_table, 3,  next_row, 'Mar',   bgcolor=#999999)
        table.cell(monthly_table, 4,  next_row, 'Apr',   bgcolor=#999999)
        table.cell(monthly_table, 5,  next_row, 'May',   bgcolor=#999999)
        table.cell(monthly_table, 6,  next_row, 'Jun',   bgcolor=#999999)
        table.cell(monthly_table, 7,  next_row, 'Jul',   bgcolor=#999999)
        table.cell(monthly_table, 8,  next_row, 'Aug',   bgcolor=#999999)
        table.cell(monthly_table, 9,  next_row, 'Sep',   bgcolor=#999999)
        table.cell(monthly_table, 10, next_row, 'Oct',   bgcolor=#999999)
        table.cell(monthly_table, 11, next_row, 'Nov',   bgcolor=#999999)
        table.cell(monthly_table, 12, next_row, 'Dec',   bgcolor=#999999)
        table.cell(monthly_table, 13, next_row, '',      bgcolor=#999999)
        table.cell(monthly_table, 14, next_row, 'Year',  bgcolor=#999999)
        
        max_alpha_abs_y = 0.0
        for yi = 0 to array.size(year_time) - 1 by 1
            if (math.abs(array.get(year_pnl, yi)  - array.get(bench_year_pnl, yi)) > max_alpha_abs_y)
                max_alpha_abs_y := math.abs(array.get(year_pnl, yi)  - array.get(bench_year_pnl, yi))
    
        max_alpha_abs_m = 0.0
        for mi = 0 to array.size(month_pnl) - 1 by 1
            if (math.abs(array.get(month_pnl, mi) - array.get(bench_month_pnl, mi)) > max_alpha_abs_m)
                max_alpha_abs_m := math.abs(array.get(month_pnl, mi) - array.get(bench_month_pnl, mi))
                
        for yi = 0 to array.size(year_time) - 1 by 1
            table.cell(monthly_table, 0,  yi + 1 + next_row + 1, str.tostring(year(array.get(year_time, yi))), bgcolor=#cccccc)
            table.cell(monthly_table, 13, yi + 1 + next_row + 1, ' ',   bgcolor=#999999)
            y_color = color.from_gradient(array.get(year_pnl, yi)  - array.get(bench_year_pnl, yi), -max_alpha_abs_y, max_alpha_abs_y, loss_color, prof_color)
            table.cell(monthly_table, 14, yi + 1 + next_row + 1, str.tostring(math.round((array.get(year_pnl, yi)  - array.get(bench_year_pnl, yi)) * 100, prec)), bgcolor=y_color)
     
        for mi = 0 to array.size(month_time) - 1 by 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 = color.from_gradient(array.get(month_pnl, mi) - array.get(bench_month_pnl, mi), -max_alpha_abs_m, max_alpha_abs_m, loss_color, prof_color)
    
            table.cell(monthly_table, m_col, m_row  + next_row + 1, str.tostring(math.round((array.get(month_pnl, mi) - array.get(bench_month_pnl, mi)) * 100, prec)), bgcolor=m_color)