Heiken Ashi dan Super Trend Strategy

Penulis:ChaoZhang, Tanggal: 2023-11-02 16:15:18
Tag:

Gambaran umum

Strategi Heiken Ashi dan Super Trend adalah strategi mengikuti tren yang menggabungkan lilin Heiken Ashi dan indikator Super Trend.

Logika Strategi

Lilin Heiken Ashi adalah jenis khusus lilin yang menggunakan rata-rata harga buka, tutup, tinggi dan rendah untuk memetakan tubuh lilin, menyaring kebisingan pasar dan membuat pola lebih jelas.

Strategi pertama menghitung lilin Heiken Ashi, kemudian menghitung indikator Super Trend berdasarkan lilin Heiken Ashi. Sinyal perdagangan dihasilkan ketika harga menembus garis Super Trend. Secara khusus, strategi menggunakan lilin Heiken Ashi untuk menghitung rentang yang sebenarnya, kemudian memperoleh band atas dan bawah Super Trend menggunakan rentang dan harga rata-rata. Sinyal panjang dihasilkan ketika harga menembus band bawah, dan sinyal pendek ketika harga menembus band bawah.

Parameter Super Trend juga dioptimalkan untuk hasil terbaik, meningkatkan sensitivitas indikator.

Analisis Keuntungan

Lilin Heiken Ashi menyaring kebisingan untuk sinyal yang lebih jelas.
Super Trend dengan cepat menangkap perubahan tren dan menghasilkan sinyal tepat waktu.
Optimasi parameter meningkatkan keandalan indikator.
Mekanisme stop loss yang dibangun secara efektif mengendalikan risiko.
Tingkat otomatisasi yang tinggi dengan menggabungkan tren mengikuti dan perdagangan otomatis.

Analisis Risiko

Otomatisasi tinggi membutuhkan pemantauan yang ketat untuk menghindari kelainan.
Heiken Ashi mungkin melewatkan sinyal pembalikan yang sangat kecil saat menyaring kebisingan.
Super Trend dapat menghasilkan sinyal palsu, menyebabkan awal masuk atau stop loss.
Penempatan stop loss yang tidak tepat juga dapat menyebabkan kerugian yang tidak perlu.
Data backtesting yang tidak cukup dapat menyebabkan overfitting.

Arahan Optimasi

Uji lebih banyak kombinasi parameter untuk lebih mengoptimalkan Super Trend.
Tambahkan indikator lain untuk mengkonfirmasi sinyal Super Trend dan mengurangi sinyal palsu.
Mengoptimalkan strategi stop loss untuk meminimalkan stop yang tidak perlu sambil mengunci keuntungan.
Menggabungkan algoritma pembelajaran mesin untuk melatih penilaian tren nyata menggunakan data besar.
Gunakan kerangka waktu yang lebih panjang dan data historis yang lebih beragam untuk backtesting untuk meningkatkan keandalan.

Ringkasan

Strategi Heiken Ashi dan Super Trend adalah strategi yang mengikuti tren. Strategi ini mengidentifikasi arah tren dan berdagang dengan tren utama, sementara dengan cepat berhenti pada pembalikan. Strategi ini mengintegrasikan penyaringan kebisingan Heiken Ashi dan deteksi perubahan tren Super Trend. Optimasi parameter dan desain stop loss memungkinkan memaksimalkan pengembalian sambil mengendalikan risiko. Optimasi masa depan dapat mencakup penyesuaian parameter lebih lanjut, konfirmasi sinyal tambahan, data backtesting yang diperluas, dll untuk meningkatkan stabilitas dan keandalan strategi.

/*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)

Lebih banyak

2019 FMZ - Semua hak dilindungi