संसाधन लोड हो रहा है... लोड करना...

गति ब्रेकआउट रणनीति

लेखक:चाओझांग, दिनांक: 2023-12-13 17:08:53
टैगः

img

अवलोकन

यह रणनीति ब्रेकआउट ट्रेडिंग को लागू करने के लिए मूविंग एवरेज, लैगुएरे आरएसआई इंडिकेटर और एडीएक्स इंडिकेटर को जोड़ती है। यह लंबी होती है जब फास्ट मूविंग एवरेज स्लो मूविंग एवरेज से ऊपर जाती है, लैगुएरे आरएसआई 80 से अधिक होता है और एडीएक्स 20 से अधिक होता है; यह छोटी होती है जब फास्ट मूविंग एवरेज स्लो मूविंग एवरेज से नीचे जाती है, लैगुएरे आरएसआई 20 से कम होता है और एडीएक्स 20 से अधिक होता है। यह रणनीति बाजार की गति विशेषताओं को पकड़ती है और प्रवृत्ति विकास की शुरुआत में बाजार में प्रवेश करती है।

सिद्धांत

रणनीति में मुख्य रूप से निम्नलिखित संकेतकों का उपयोग प्रवृत्तियों और प्रवेश के समय को निर्धारित करने के लिए किया गया है:

  1. चलती औसत संयोजनः 16-दिवसीय ईएमए, 48-दिवसीय ईएमए, 200-दिवसीय एसएमए. एक अपट्रेंड निर्धारित किया जाता है जब अल्पकालिक औसत दीर्घकालिक औसत से ऊपर पार करता है, और नीचे पार करने पर एक डाउनट्रेंड।

  2. Laguerre RSI सूचक ओवरबॉट और ओवरसोल्ड जोन निर्धारित करने के लिए। 80 से अधिक RSI एक लंबा संकेत है, और 20 से कम एक छोटा संकेत है।

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

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

ताकत

इस रणनीति के लाभों में निम्नलिखित शामिल हैंः

  1. प्रवृत्ति गति पकड़ना: रणनीति केवल प्रवृत्ति विकास की शुरुआत में बाजार में प्रवेश करती है, प्रवृत्तियों से घातीय लाभ प्राप्त करती है।

  2. सीमित घाटे: स्टॉप लॉस को उचित रूप से सेट करके व्यक्तिगत ट्रेडों से होने वाले घाटे को सीमित किया जाता है।

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

  4. सरल कार्यान्वयनः रणनीति में केवल 3 संकेतकों का उपयोग किया गया है और इसे समझना और लागू करना आसान है।

जोखिम

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

  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")


अधिक