संयुक्त गति ब्रेकआउट रणनीति


निर्माण तिथि: 2023-12-13 17:08:53 अंत में संशोधित करें: 2023-12-13 17:08:53
कॉपी: 6 क्लिक्स: 599
1
ध्यान केंद्रित करना
1621
समर्थक

संयुक्त गति ब्रेकआउट रणनीति

अवलोकन

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

सिद्धांत

यह रणनीति मुख्य रूप से निम्नलिखित संकेतकों के आधार पर प्रवृत्ति और लॉन्च समय को मापती हैः

  1. चलती औसत संयोजनः 16 दिन का ईएमए, 48 दिन का ईएमए, 200 दिन का एसएमए। इसे ओवरहेड बाजार के रूप में माना जाता है जब यह लंबी अवधि के औसत को शॉर्ट एवरेज पर डालता है, और इसे खाली बाजार के रूप में नीचे डालता है।

  2. Laguerre RSI सूचक ओवरबॉट ओवरसोल्ड क्षेत्र को निर्धारित करता है। 80 से अधिक RSI एक बहु-हेड सिग्नल है, 20 से कम एक शून्य-हेड सिग्नल है।

  3. ADX संकेतक प्रवृत्ति की स्थिति का आकलन करता है. ADX 20 से अधिक प्रवृत्ति की स्थिति को दर्शाता है, जो एक ब्रेक ट्रेड के लिए उपयुक्त है।

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

लाभ

इस रणनीति के निम्नलिखित फायदे हैं:

  1. प्रवृत्ति गतिशीलता को पकड़नाः यह रणनीति केवल प्रवृत्ति के विकास के शुरू होने के समय में प्रवेश करती है, जो बाद के बाजारों के सूचकांक स्तर के मुनाफे को पकड़ने में मदद करती है।

  2. सीमित हानि: उचित रूप से सेट स्टॉप लॉस के साथ, एकल हानि को एक निश्चित सीमा तक नियंत्रित किया जा सकता है। यहां तक कि अगर आप जेल में हैं, तो भी लाभ कमाने का अवसर है।

  3. संकेतक पोर्टफोलियो का निर्णय सटीकता: चलती औसत, लागुएरे आरएसआई और एडीएक्स संकेतक बाजार में अधिकता और प्रवेश के समय का अनुमान लगाने में अपेक्षाकृत सटीक हैं।

  4. सरलता: इस रणनीति को लागू करने के लिए केवल तीन मापदंडों का उपयोग किया गया है, जो सरल और आसानी से समझने योग्य है।

जोखिम

इस रणनीति में कुछ जोखिम भी हैं:

  1. रुझान में बदलाव का जोखिमः रणनीति रुझान का पालन करने वाली रणनीति है, अगर समय पर रुझान में बदलाव का आकलन नहीं किया जाता है, तो अधिक नुकसान हो सकता है।

  2. निकासी जोखिमः अस्थिरता के दौरान, स्टॉप लॉस को तोड़ दिया जा सकता है, जिससे खाते को वापस ले लिया जा सकता है।

  3. पैरामीटर अनुकूलन जोखिमः सूचकांक पैरामीटर को विभिन्न बाजारों के अनुसार समायोजित करने की आवश्यकता होती है, अन्यथा यह विफल हो जाएगा।

क्या करें?

  1. सख्ती से रोकना, एकल हानि को नियंत्रित करना।

  2. सूचकांक मापदंडों को अनुकूलित करें, ब्रेकआउट की संख्या को समायोजित करें

  3. फ्यूचर्स सेट के लिए वैल्यूएशन की व्यवस्था करना।

अनुकूलन दिशा

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

  1. इष्टतम पैरामीटर अनुकूलनः चलती औसत अवधि, लागुएरे आरएसआई पैरामीटर और एडीएक्स पैरामीटर का परीक्षण करके इष्टतम पैरामीटर संयोजन की तलाश करें।

  2. ब्रेकआउट ऑप्टिमाइज़ेशनः विभिन्न चलती औसत ब्रेकआउट का परीक्षण करें और ट्रेडों की संख्या और लाभ दर के बीच संतुलन ढूंढें।

  3. प्रवेश की शर्तों का अनुकूलनः अन्य संकेतकों को लैगुएरे आरएसआई के साथ संयोजन में परीक्षण करना, प्रवेश के समय को अधिक सटीक रूप से निर्धारित करने के लिए शर्तों की तलाश करना।

  4. बाहर निकलने की स्थिति का अनुकूलनः अन्य संकेतकों का अध्ययन चलती औसत के साथ एक अधिक सटीक बाहर निकलने के संकेत के रूप में किया जाता है।

  5. लाभप्रदता लक्ष्य और रोकथाम अनुकूलनः विभिन्न रोकथाम और रोकथाम रणनीतियों का परीक्षण करें और खाते के लाभ को अनुकूलित करें।

संक्षेप

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

रणनीति स्रोत कोड
/*backtest
start: 2023-12-05 00:00:00
end: 2023-12-12 00:00:00
period: 1m
basePeriod: 1m
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/
// © PtGambler

//@version=5
strategy("3MA + Laguerre RSI + ADX [Pt]", shorttitle = "3MA+LaRSI+ADX[Pt]", overlay=true, initial_capital = 10000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills = false, max_bars_back = 500)


// ********************************** Trade Period / Strategy Setting **************************************
startY = input(title='Start Year', defval=2011, group = "Backtesting window")
startM = input.int(title='Start Month', defval=1, minval=1, maxval=12, group = "Backtesting window")
startD = input.int(title='Start Day', defval=1, minval=1, maxval=31, group = "Backtesting window")
finishY = input(title='Finish Year', defval=2050, group = "Backtesting window")
finishM = input.int(title='Finish Month', defval=12, minval=1, maxval=12, group = "Backtesting window")
finishD = input.int(title='Finish Day', defval=31, minval=1, maxval=31, group = "Backtesting window")
timestart = timestamp(startY, startM, startD, 00, 00)
timefinish = timestamp(finishY, finishM, finishD, 23, 59)
use_entry_sess = input.bool(false, 'Use Entry Session Window', group = "Trading Session")
t1_session = input("0930-1555:23456", "Entry Session", group="Trading Session", tooltip = "Entry Signal only generated within this period.") 
t1 = time(timeframe.period, t1_session)
window = true

margin_req = input.float(1, title="Margin Requirement / Leverage", step=0.1, group = "Trading Options")
qty_per_trade = input.float(100, title = "% of initial capital per trade", group = "Trading Options")
reinvest = input.bool(defval=false,title="Reinvest profit", group = "Trading Options")
reinvest_percent = input.float(defval=100, title = "Reinvest percentage", group="Trading Options")

close_eod = input.bool(false, "All trades will close at the close of trading window", group = "Trading Options")
close_b4_open = input.bool(false, "Position must hit either SL/PT before entering new trade", group = "Trading Options")

profit = strategy.netprofit 
strategy.initial_capital = 50000
float trade_amount = math.floor(strategy.initial_capital*margin_req / close) 

if strategy.netprofit > 0 and reinvest
    trade_amount := math.floor((strategy.initial_capital* (qty_per_trade/100)+(profit*reinvest_percent*0.01))*margin_req/ close) 
else
    trade_amount := math.floor(strategy.initial_capital* (qty_per_trade/100)*margin_req / close)  

// ******************************************************************************************

group_ma = "Moving Average Ribbon"
group_larsi = "Laguerre RSI"
group_adx = "ADX"
group_SL = "Stop Loss / Profit Target"

// ----------------------------------------- MA Ribbon -------------------------------------

ema1_len = input.int(16, "Fast EMA Length", group = group_ma)
ema2_len = input.int(48, "Slow EMA Length ", group = group_ma)
sma1_len = input.int(200, "Slow SMA Length", group = group_ma)

ema1 = ta.ema(close, ema1_len)
ema2 = ta.ema(close, ema2_len)
sma1 = ta.sma(close, sma1_len)

plot(ema1, "EMA 1", color.white, linewidth = 2)
plot(ema2, "EMA 2", color.yellow, linewidth = 2)
plot(sma1, "SMA 1", color.purple, linewidth = 2)

ma_bull = ema1 > ema2 and ema2 > sma1   
ma_bear = ema1 < ema2 and ema2 < sma1

// ------------------------------------------ Laguerre RSI ---------------------------------------

alpha = input.float(0.2, title='Alpha', minval=0, maxval=1, step=0.1, group = group_larsi)

gamma = 1 - alpha
L0 = 0.0
L0 := (1 - gamma) * close + gamma * nz(L0[1])
L1 = 0.0
L1 := -gamma * L0 + nz(L0[1]) + gamma * nz(L1[1])

L2 = 0.0
L2 := -gamma * L1 + nz(L1[1]) + gamma * nz(L2[1])

L3 = 0.0
L3 := -gamma * L2 + nz(L2[1]) + gamma * nz(L3[1])

cu = (L0 > L1 ? L0 - L1 : 0) + (L1 > L2 ? L1 - L2 : 0) + (L2 > L3 ? L2 - L3 : 0)

cd = (L0 < L1 ? L1 - L0 : 0) + (L1 < L2 ? L2 - L1 : 0) + (L2 < L3 ? L3 - L2 : 0)

temp = cu + cd == 0 ? -1 : cu + cd
LaRSI = temp == -1 ? 0 : cu / temp
LaRSI := LaRSI * 100

bull_LaRSI = LaRSI > 80
bear_LaRSI = LaRSI < 20

// --------------------------------------- ADX  ------------------------

adxlen = input(14, title="ADX Smoothing", group = group_adx)
dilen = input(14, title="DI Length", group = group_adx)
dirmov(len) =>
	up = ta.change(high)
	down = -ta.change(low)
	plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
	minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
	truerange = ta.rma(ta.tr, len)
	plus = fixnan(100 * ta.rma(plusDM, len) / truerange)
	minus = fixnan(100 * ta.rma(minusDM, len) / truerange)
	[plus, minus]
adx(dilen, adxlen) =>
	[plus, minus] = dirmov(dilen)
	sum = plus + minus
	adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen)
sig = adx(dilen, adxlen)

active_adx = sig > 20 //and sig > sig[1]

// ******************************* Profit Target / Stop Loss *********************************************

use_SLPT = input.bool(false, 'Use Fixed SL / PT', group = group_SL)
SL = input.float(50, 'Stop loss in ticks', step = 1, group = group_SL) * syminfo.mintick
PT = input.float(100, "Profit target in ticks", step = 1, group = group_SL) * syminfo.mintick

var L_PT = 0.0
var S_PT = 0.0
var L_SL = 0.0
var S_SL = 0.0

if strategy.position_size > 0
    L_SL := L_SL[1]
    L_PT := L_PT[1]
else if strategy.position_size < 0
    S_SL := S_SL[1]
    S_PT := S_PT[1]
else
    L_SL := close - SL
    L_PT := close + PT
    S_SL := close + SL
    S_PT := close - PT

entry_line = plot(use_SLPT and strategy.position_size != 0 ? strategy.opentrades.entry_price(0) : na, "Entry Price", color.white, linewidth = 1, style = plot.style_linebr)

L_PT_line = plot(use_SLPT and strategy.position_size > 0 ? L_PT : na, "L PT", color.green, linewidth = 2, style = plot.style_linebr)
S_PT_line = plot(use_SLPT and strategy.position_size < 0 ? S_PT : na, "S PT", color.green, linewidth = 2, style = plot.style_linebr)

L_SL_line = plot(use_SLPT and strategy.position_size > 0 ? L_SL : na, "L SL", color.red, linewidth = 2, style = plot.style_linebr)
S_SL_line = plot(use_SLPT and strategy.position_size < 0 ? S_SL : na, "S SL", color.red, linewidth = 2, style = plot.style_linebr)

fill(L_PT_line, entry_line, color = color.new(color.green,90))
fill(S_PT_line, entry_line, color = color.new(color.green,90))
fill(L_SL_line, entry_line, color = color.new(color.red,90))
fill(S_SL_line, entry_line, color = color.new(color.red,90))


// ---------------------------------- Strategy setup ------------------------------------------------------

L_entry1 = ma_bull and bull_LaRSI and active_adx
S_entry1 = ma_bear and bear_LaRSI and active_adx

L_exit1 = ta.crossunder(ema1, ema2)
S_exit1 = ta.crossover(ema1, ema2)

// Trigger zones
bgcolor(ma_bull ? color.new(color.green ,90) : na)
bgcolor(ma_bear ? color.new(color.red,90) : na)

if L_entry1 and (use_entry_sess ? window : true) and (close_b4_open ? strategy.position_size == 0 : true)
    strategy.entry("Long", strategy.long, trade_amount)

if S_entry1 and (use_entry_sess ? window : true) and (close_b4_open ? strategy.position_size == 0 : true)
    strategy.entry("Short", strategy.short, trade_amount)

if use_SLPT
    strategy.exit("Exit Long", "Long", limit = L_PT, stop = L_SL, comment_profit = "Exit Long, PT hit", comment_loss = "Exit Long, SL hit")
    strategy.exit("Exit Short", "Short", limit = S_PT, stop = S_SL, comment_profit = "Exit Short, PT hit", comment_loss = "Exit Short, SL hit")
else
    if L_exit1
        strategy.close("Long", comment = "Exit Long")

    if S_exit1
        strategy.close("Short", comment = "Exit Short")

if use_entry_sess and not window and close_eod
    strategy.close_all(comment = "EOD close")