लंदन ब्रेकआउट डे ट्रेडिंग रणनीति

लेखक:चाओझांग, दिनांक: 2023-09-15 15:43:04
टैगः

रणनीति का अवलोकन

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

रणनीति तर्क

  1. व्यापार केवल सप्ताह के दिनों में लंदन सत्र घंटों के दौरान किया जाता है, उदाहरण के लिए GMT 0400-0500।

  2. अल्पकालिक प्रवृत्ति निर्धारित करें: लगातार 3 ऊपर की मोमबत्तियों पर लंबी, लगातार 3 नीचे की मोमबत्तियों पर छोटी जाएं।

  3. लम्बा संकेतः जब आप लगातार 3 ऊपर मोमबत्तियाँ देखते हैं तो लम्बा दर्ज करें.

  4. संक्षिप्त संकेतः जब आप लगातार तीन नीचे मोमबत्तियाँ देखते हैं तो संक्षिप्त दर्ज करें।

  5. स्टॉप लॉस/टेक प्रॉफिटः स्टॉप लॉस सेट करें और प्रवेश मूल्य से एक निश्चित प्रतिशत पर प्रॉफिट लें।

  6. बाहर निकलने के नियमः स्टॉप लॉस/टेक प्रॉफिट ट्रिगर पर बाहर निकलें, या लंदन सत्र समाप्त होने पर।

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

रणनीति के फायदे

  • केवल अत्यधिक सक्रिय लंदन घंटों के दौरान व्यापार

  • संकेतों के लिए सरल मूल्य ब्रेकआउट तर्क

  • सख्त स्टॉप लॉस/टेक प्रॉफिट नियंत्रण जोखिम

  • रात और अवकाश सत्रों में कम तरलता से बचा जाता है

  • स्पष्ट प्रवेश और निकास नियम

जोखिम चेतावनी

  • संभावित समय से पहले या देरी से प्रवेश के मुद्दे

  • फंसने का खतरा

  • रातों / छुट्टियों के दौरान अवसर सामने आ सकते हैं

  • प्रमुख समर्थन/प्रतिरोध स्तरों पर ध्यान देने की आवश्यकता है

निष्कर्ष

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


/*backtest
start: 2023-09-07 00:00:00
end: 2023-09-08 09:00:00
period: 30m
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("time zone", overlay=true, initial_capital=1000)
fromDay = input(defval = 1, title = "From Day", minval = 1, maxval = 31)
fromMonth = input(defval = 1, title = "From Month", minval = 1, maxval = 12)
fromYear = input(defval = 2000, title = "From Year", minval = 1970)
 //monday and session 
// To Date Inputs
toDay = input(defval = 31, title = "To Day", minval = 1, maxval = 31)
toMonth = input(defval = 12, title = "To Month", minval = 1, maxval = 12)
toYear = input(defval = 2020, title = "To Year", minval = 1970)

startDate = timestamp(fromYear, fromMonth, fromDay, 00, 00)
finishDate = timestamp(toYear, toMonth, toDay, 00, 00)
time_cond = true

s = input(title="Session", type=input.session, defval="0400-0500")
s2 = input(title="eXOT", type=input.session, defval="0300-0900")
t1 = time(timeframe.period, s)
t2 = time(timeframe.period, s2)
c2 = #0000FF
//bgcolor(t1 ? c2 : na, transp=85)

UseHAcandles    = input(false, title="Use Heikin Ashi Candles in Algo Calculations")
//
// === /INPUTS ===

// === BASE FUNCTIONS ===

haClose = UseHAcandles ? security(heikinashi(syminfo.tickerid), timeframe.period, close) : close
haOpen  = UseHAcandles ? security(heikinashi(syminfo.tickerid), timeframe.period, open) : open
haHigh  = UseHAcandles ? security(heikinashi(syminfo.tickerid), timeframe.period, high) : high
haLow   = UseHAcandles ? security(heikinashi(syminfo.tickerid), timeframe.period, low) : low

isMon() => dayofweek(time('D')) == dayofweek.monday
isTue() => dayofweek(time('D')) == dayofweek.tuesday
isWed() => dayofweek(time('D')) == dayofweek.wednesday
isThu() => dayofweek(time('D')) == dayofweek.thursday
isFri() => dayofweek(time('D')) == dayofweek.friday
isSat() => dayofweek(time('D')) == dayofweek.saturday
isSun() => dayofweek(time('D')) == dayofweek.sunday

longe = input(true, title="LONG only")
shorte = input(true, title="SHORT only")
//sl=input(0.001, title="sl % price movement")
//accbalance = strategy.initial_capital + strategy.netprofit


entry = close

sl = input(0.005, title = "Stop Loss")
tp = input(0.005, title="Target Price")

// sldist = entry - sl
// tgdist = tp - entry 
// slper = sldist / entry * 100
// tgper = tgdist / entry * 100

// rr = tgper / slper
// size = accbalance * riskper / slper

balance = strategy.netprofit + 50000 //current balance
floating = strategy.openprofit          //floating profit/loss
risk = input(1,type=input.float,title="Risk % of equity ")           //risk % per trade


temp01 = (balance * risk)/100     //Risk in USD
temp02 = temp01/close*sl      //Risk in lots
temp03 = temp02*100000      //Convert to contracts
size = temp03 - temp03%1000 //Normalize to 1000s (Trade size)
if(size < 1000)
    size := 1000           //Set min. lot size



longC =  haClose> haClose[1] and  haClose[1] > haClose[2]  and haClose[2] <  haClose[3] 
shortC = haClose < haClose[1] and   haClose[1] < haClose[2]  and haClose[2] > haClose[3] 


luni = input(true, title="Monday")
marti = input(true, title="Tuesday")
miercuri = input(true, title="Wednesday")
joi = input(true, title="Thursday")
vineri = input(true, title="Friday")
if(time_cond)
    if(t1)
        if(luni==true and dayofweek == dayofweek.monday)
            if(longC and longe )
                strategy.entry("long",1)
            if(shortC and shorte)
                strategy.entry("short",0)
                
        if(marti==true and dayofweek == dayofweek.tuesday)
            if(longC and longe )
                strategy.entry("long",1)
            if(shortC and shorte)
                strategy.entry("short",0)
                
        if(miercuri==true and dayofweek == dayofweek.wednesday)
            if(longC and longe  )
                strategy.entry("long",1)
            if(shortC and shorte)
                strategy.entry("short",0)
                
        if(joi==true  and dayofweek == dayofweek.thursday)
            if(longC and longe)
                strategy.entry("long",1)
            if(shortC and shorte)
                strategy.entry("short",0)
                
        if(vineri==true and  dayofweek == dayofweek.friday)
            if(longC and longe)
                strategy.entry("long",1 )
            if(shortC and shorte)
                strategy.entry("short",0)  


//strategy.exit("closelong", "RSI_BB_LONG" , profit = close * 0.01 / syminfo.mintick, loss = close * 0.01 / syminfo.mintick, alert_message = "closelong")
//strategy.exit("closeshort", "RSI_BB_SHORT" , profit = close * 0.01 / syminfo.mintick, loss = close * 0.01 / syminfo.mintick, alert_message = "closeshort")

strategy.exit("sl","long", loss = close * sl / syminfo.mintick, profit = close * tp / syminfo.mintick)
strategy.exit("sl","short", loss=close * sl / syminfo.mintick, profit = close * tp / syminfo.mintick)

//strategy.close("long")
//strategy.close("short" )

//strategy.exit("sl","long", loss = sl)
//strategy.exit("sl","short", loss= sl)

if(not t2)
    strategy.close_all()
//strategy.risk.max_intraday_filled_orders(2)





अधिक