হেইকেন আশি এবং সুপার ট্রেন্ড কৌশল

লেখক:চাওঝাং, তারিখ: ২০২৩-১১-০২ ১৬ঃ১৫ঃ১৮
ট্যাগঃ

সারসংক্ষেপ

হেইকেন আশি এবং সুপার ট্রেন্ড কৌশল হ'ল একটি প্রবণতা অনুসরণকারী কৌশল যা হেইকেন আশি মোমবাতি এবং সুপার ট্রেন্ড সূচককে একত্রিত করে। এটি প্রবণতার দিক সনাক্ত করতে, প্রবণতার সাথে বাণিজ্য করতে এবং প্রবণতা বিপরীত হলে দ্রুত বেরিয়ে আসার লক্ষ্যে, প্রবণতা-বিহীন ব্যবসায় থেকে ক্ষতি হ্রাস করতে।

কৌশলগত যুক্তি

হেইকেন আশি মোমবাতি একটি বিশেষ ধরনের মোমবাতি যা মোমবাতির দেহগুলি প্লট করার জন্য খোলা, বন্ধ, উচ্চ এবং নিম্ন মূল্যের গড় ব্যবহার করে, বাজারের গোলমাল ফিল্টার করে এবং প্যাটার্নটি আরও স্পষ্ট করে তোলে। সুপার ট্রেন্ড সূচকটি প্রবণতা দিক নির্ধারণের জন্য গতিশীল সমর্থন এবং প্রতিরোধ গঠনকারী দুটি লাইন নিয়ে গঠিত।

কৌশলটি প্রথমে হেইকেন আশি মোমবাতি গণনা করে, তারপরে হেইকেন আশি মোমবাতিগুলির উপর ভিত্তি করে সুপার ট্রেন্ড সূচক গণনা করে। যখন দাম সুপার ট্রেন্ড লাইনগুলি ভেঙে যায় তখন ট্রেডিং সংকেত উত্পন্ন হয়। বিশেষত, কৌশলটি সত্যিকারের পরিসীমা গণনা করতে হেইকেন আশি মোমবাতি ব্যবহার করে, তারপরে পরিসীমা এবং গড় মূল্য ব্যবহার করে সুপার ট্রেন্ডের উপরের এবং নীচের ব্যান্ডগুলি বের করে। দামটি নিম্ন ব্যান্ডের উপরে ভাঙলে লং সংকেত উত্পন্ন হয় এবং দামটি উপরের ব্যান্ডের নীচে ভাঙলে সংক্ষিপ্ত সংকেত উত্পন্ন হয়।

সুপার ট্রেন্ড প্যারামিটারগুলিও সর্বোত্তম ফলাফলের জন্য অনুকূলিত করা হয়, সূচকের সংবেদনশীলতা উন্নত করে। এছাড়াও, লাভ লক করার সময় ঝুঁকি নিয়ন্ত্রণের জন্য একটি স্টপ লস প্রক্রিয়া বাস্তবায়ন করা হয়।

সুবিধা বিশ্লেষণ

হেইকেন আশি মোমবাতি পরিষ্কার সংকেতের জন্য শব্দ ফিল্টার করে।
সুপার ট্রেন্ড দ্রুত ট্রেন্ডের পরিবর্তনগুলি ধরতে পারে এবং সময়মত সংকেত তৈরি করতে পারে।
প্যারামিটার অপ্টিমাইজেশান সূচকের নির্ভরযোগ্যতা উন্নত করে।
বিল্ট ইন স্টপ লস প্রক্রিয়া কার্যকরভাবে ঝুঁকি নিয়ন্ত্রণ করে।
প্রবণতা অনুসরণ এবং স্বয়ংক্রিয় ট্রেডিংয়ের সমন্বয়ে স্বয়ংক্রিয়তার উচ্চ স্তর।

ঝুঁকি বিশ্লেষণ

উচ্চ স্বয়ংক্রিয়তা অস্বাভাবিকতা এড়াতে ঘনিষ্ঠ পর্যবেক্ষণ প্রয়োজন।
Heiken Ashi শব্দ ফিল্টার করার সময় খুব ছোট বিপরীত সংকেত মিস করতে পারে।
সুপার ট্রেন্ড মিথ্যা সংকেত তৈরি করতে পারে, যা অকাল প্রবেশ বা স্টপ লস হতে পারে।
ভুল স্টপ লস প্লেসমেন্ট অপ্রয়োজনীয় ক্ষতির কারণ হতে পারে।
ব্যাকটেস্টিংয়ের তথ্যের অভাবে অতিরিক্ত ফিটিং হতে পারে। লাইভ ফলাফল ব্যাকটেস্ট থেকে উল্লেখযোগ্যভাবে বিচ্যুত হতে পারে।

অপ্টিমাইজেশান নির্দেশাবলী

সুপার ট্রেন্ডকে আরও উন্নত করার জন্য আরো প্যারামিটার সমন্বয় পরীক্ষা করুন।
সুপার ট্রেন্ড সংকেত নিশ্চিত করতে এবং মিথ্যা সংকেত হ্রাস করতে অন্যান্য সূচক যুক্ত করুন।
অপ্রয়োজনীয় স্টপ হ্রাস কৌশলটি অপ্টিমাইজ করুন লাভের লকিংয়ের সময় অপ্রয়োজনীয় স্টপগুলি হ্রাস করতে।
বিগ ডেটা ব্যবহার করে বাস্তব প্রবণতা সম্পর্কে বিচার করার জন্য মেশিন লার্নিং অ্যালগরিদম অন্তর্ভুক্ত করা।
নির্ভরযোগ্যতা উন্নত করতে ব্যাকটেস্টিংয়ের জন্য দীর্ঘ সময়সীমা এবং আরও বৈচিত্র্যময় historicalতিহাসিক ডেটা ব্যবহার করুন।

সংক্ষিপ্তসার

হেইকেন আশি এবং সুপার ট্রেন্ড কৌশল একটি প্রবণতা অনুসরণকারী কৌশল। এটি প্রধান প্রবণতার সাথে প্রবণতা দিক এবং ব্যবসায়ের চিহ্নিত করে, দ্রুত বিপরীতমুখী অবস্থায় দ্রুত থামিয়ে দেয়। কৌশলটি হেইকেন আশির গোলমাল ফিল্টারিং এবং সুপার ট্রেন্ডের দ্রুত প্রবণতা পরিবর্তন সনাক্তকরণকে সংহত করে। পরামিতি অপ্টিমাইজেশন এবং স্টপ লস ডিজাইন ঝুঁকি নিয়ন্ত্রণের সময় সর্বাধিক রিটার্নের অনুমতি দেয়। ভবিষ্যতের অপ্টিমাইজেশনে কৌশলটির স্থায়িত্ব এবং নির্ভরযোগ্যতা বাড়ানোর জন্য আরও পরামিতি টিউনিং, অতিরিক্ত সংকেত নিশ্চিতকরণ, বর্ধিত ব্যাকটেস্টিং ডেটা ইত্যাদি অন্তর্ভুক্ত থাকতে পারে।

/*backtest
start: 2022-10-26 00:00:00
end: 2023-11-01 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5

strategy("Heiken Ashi & Super Trend_ARM", overlay=true,  pyramiding=1,initial_capital = 10000, default_qty_type= strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills=false, slippage=0,commission_type=strategy.commission.percent,commission_value=0.02)

///////////////////////////////////////////////////
////////////////////Function///////////////////////
///////////////////////////////////////////////////


heikinashi_open = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, open)
heikinashi_high = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, high)
heikinashi_low  = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, low)
heikinashi_close= request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close)
heikinashi_color = heikinashi_open < heikinashi_close ? #53b987 : #eb4d5c
// plotbar(heikinashi_open, heikinashi_high, heikinashi_low, heikinashi_close, color=heikinashi_color)

x_sma(x, y) =>
    sumx = 0.0
    for i = 0 to y - 1
        sumx := sumx + x[i] / y
    sumx

x_rma(src, length) =>
	alpha = 1/length
	sum = 0.0
	sum := na(sum[1]) ? x_sma(src, length) : alpha * src + (1 - alpha) * nz(sum[1])

x_atr(length) =>
    trueRange = na(heikinashi_high[1])? heikinashi_high-heikinashi_low : math.max(math.max(heikinashi_high - heikinashi_low, math.abs(heikinashi_high - heikinashi_close[1])), math.abs(heikinashi_low - heikinashi_close[1]))
    //true range can be also calculated with ta.tr(true)
    x_rma(trueRange, length)

x_supertrend(factor, atrPeriod) =>
	src = (heikinashi_high+heikinashi_low)/2
	atr = x_atr(atrPeriod)
	upperBand = src + factor * atr
	lowerBand = src - factor * atr
	prevLowerBand = nz(lowerBand[1])
	prevUpperBand = nz(upperBand[1])

	lowerBand := lowerBand > prevLowerBand or heikinashi_close[1] < prevLowerBand ? lowerBand : prevLowerBand
	upperBand := upperBand < prevUpperBand or heikinashi_close[1] > prevUpperBand ? upperBand : prevUpperBand
	int direction = na
	float superTrend = na
	prevSuperTrend = superTrend[1]
	if na(atr[1])
		direction := 1
	else if prevSuperTrend == prevUpperBand
		direction := heikinashi_close > upperBand ? -1 : 1
	else
		direction := heikinashi_close < lowerBand ? 1 : -1
	superTrend := direction == -1 ? lowerBand : upperBand
	[superTrend, direction]
	

///////////////////////////////////////////////////
////////////////////Indicators/////////////////////
///////////////////////////////////////////////////

factor = input.float(3.0, "Factor", step = 0.01)
atrPeriod = input(10, "ATR Length")


[supertrend, direction] = x_supertrend(factor, atrPeriod)

bodyMiddle = plot((heikinashi_open + heikinashi_close) / 2, display=display.none)
upTrend = plot(direction < 0 ? supertrend : na, "Up Trend", color = color.green, style=plot.style_linebr)
downTrend = plot(direction < 0? na : supertrend, "Down Trend", color = color.red, style=plot.style_linebr)

fill(bodyMiddle, upTrend, color.new(color.green, 90), fillgaps=false)
fill(bodyMiddle, downTrend, color.new(color.red, 90), fillgaps=false)

///////////////////////////////////////////////////
////////////////////Strategy///////////////////////
///////////////////////////////////////////////////

var bool longCond                    = na, var bool shortCond                   = na, longCond := nz(longCond[1]), shortCond := nz(shortCond[1])
var int CondIni_long                 = 0, var int CondIni_short                 = 0, CondIni_long := nz(CondIni_long[1]), CondIni_short := nz(CondIni_short[1])
var float open_longCondition         = na, var float open_shortCondition   = na


long  = ta.change(direction) < 0
short = ta.change(direction) > 0


longCond        :=                                                              long
shortCond       :=                                                              short

CondIni_long    :=                                                              longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_long[1])
CondIni_short   :=                                                              longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_short[1])
longCondition   =                                                               (longCond[1] and nz(CondIni_long[1]) == -1)
shortCondition  =                                                               (shortCond[1] and nz(CondIni_short[1]) == 1)


open_longCondition             :=                                          long ? close[1] :                                                      nz(open_longCondition[1])
open_shortCondition            :=                                          short ? close[1] :                                                     nz(open_shortCondition[1])


//TP
tp                    = input.float(1.1  , "TP [%]",                      step = 0.1) 

//BACKTESTING inputs --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

testStartYear       =                   input.int(2000,                             title="start year",                                         minval = 1997, maxval = 3000,                                                   group= "BACKTEST") 
testStartMonth      =                   input.int(01,                               title="start month",                                        minval = 1, maxval = 12,                                                        group= "BACKTEST")
testStartDay        =                   input.int(01,                               title="start day",                                          minval = 1, maxval = 31,                                                        group= "BACKTEST")
testPeriodStart     =                   timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear        =                   input.int(3333,                             title="stop year",                                          minval=1980, maxval = 3333,                                                     group= "BACKTEST")
testStopMonth       =                   input.int(12,                               title="stop month",                                         minval=1, maxval=12,                                                            group= "BACKTEST")
testStopDay         =                   input.int(31,                               title="stop day",                                           minval=1, maxval=31,                                                            group= "BACKTEST")
testPeriodStop      =                   timestamp(testStopYear, testStopMonth, testStopDay, 0, 0)
testPeriod          =                   time >= testPeriodStart and time <= testPeriodStop ? true : false

// Backtest  ==================================================================================================================================================================================================================================================================================================================================


if longCond
    strategy.entry("L", strategy.long, when=testPeriod)

if shortCond
    strategy.entry("S", strategy.short, when=testPeriod)
    

strategy.exit("TP_L", "L", profit =((open_longCondition   *       (1+(tp/100))) - open_longCondition)/syminfo.mintick)

strategy.exit("TP_S", "S", profit =((open_shortCondition  *       (1+(tp/100))) - open_shortCondition)/syminfo.mintick)

আরো

2019 FMZ - সমস্ত অধিকার সংরক্ষিত