Strategi Perdagangan Rata-rata Pergerakan Halus Ganda

Tanggal Pembuatan: 2023-10-13 15:45:58 Akhirnya memodifikasi: 2023-10-13 15:45:58

menyalin: 1 Jumlah klik: 642

ChaoZhang

fokus pada Pesan pribadi

fokus pada

1617

Pengikut

Ringkasan

Strategi ini menggunakan sistem dual smoothed moving average sebagai sinyal perdagangan utama, sementara digabungkan dengan indikator verifikasi volume transaksi TDFI untuk memfilter sinyal perdagangan untuk memanfaatkan keuntungan dari smoothed moving average dan mengurangi kesalahan perdagangan di lingkungan pasar non-mainstream.

Prinsip Strategi

Strategi ini menggunakan dua set berbeda parameter yang berbeda yang bekerja sama dengan kelompok rata-rata bergerak yang halus sebagai sinyal perdagangan utama. Pertama, menggunakan set cepat dari 8 siklus rata-rata bergerak yang halus bekerja sama sebagai sinyal konfirmasi pertama, dan kemudian menggunakan 16 siklus rata-rata bergerak yang lebih lambat sebagai sinyal konfirmasi kedua. Ketika rata-rata bergerak cepat mengeluarkan sinyal beli, jika rata-rata bergerak yang lebih lambat juga mengeluarkan sinyal ke arah yang sama, dan dalam 1 hingga 2 garis K yang paling baru, maka lebih banyak posisi dibuka. Ketika rata-rata bergerak cepat mengeluarkan sinyal jual, jika rata-rata bergerak yang lebih lambat juga mengeluarkan sinyal ke arah yang sama, dan dalam 1 hingga 2 garis K yang paling baru, maka posisi dibuka.

Keunggulan Strategis

Rata-rata bergerak halus dapat secara efektif melacak tren, menghindari pengaruh dari kebisingan pasar, dan membantu menangkap tren garis tengah dan panjang
Kombinasi rata-rata bergerak ganda yang dapat meningkatkan keandalan sinyal dan menghindari kesalahan perdagangan di pasar non-mainstream
Pengenalan indikator volume transaksi, yang dapat menyaring sinyal yang menyesatkan yang disebabkan oleh volume rendah, untuk menghindari kerugian yang tidak perlu
Optimasi parameter kebijakan yang luas, dapat disesuaikan dengan varietas dan siklus yang berbeda, beradaptasi kuat

Risiko Strategis

Sistem rata-rata bergerak yang halus mudah terlambat mengenali sinyal pada titik pembalikan tren, yang dapat menyebabkan kerugian tertentu
Dalam kondisi non-epidemi, rata-rata bergerak ganda tetap mungkin untuk mengirimkan sinyal yang salah pada saat yang sama
Indikator volume transaksi terbatas, tidak dapat sepenuhnya menghindari semua sinyal yang menyesatkan

Untuk mengurangi risiko di atas, optimasi berikut dapat dipertimbangkan:

Menambahkan indikator kekuatan tren untuk membantu menentukan titik balik tren
Mengoptimalkan parameter rata-rata bergerak yang halus untuk membuat konfigurasi lambat lebih masuk akal
Mencoba indikator volume transaksi yang berbeda untuk meningkatkan filter terhadap sinyal yang menyesatkan

Arah optimasi strategi

Menambahkan indikator tambahan seperti MACD untuk menentukan titik balik tren
Menyesuaikan parameter ATR stop-loss dengan karakteristik varietas yang berbeda
Mencoba untuk meningkatkan rasio posisi untuk meningkatkan strategi pengembalian
Optimalisasi parameter berdasarkan hasil pengamatan ulang untuk meningkatkan stabilitas strategi

Meringkaskan

Strategi ini secara keseluruhan adalah strategi pelacakan tren yang khas. Sistem rata-rata bergerak ganda yang disesuaikan dengan indikator penyaringan volume transaksi TDFI, dapat memberikan fungsi pelacakan tren yang lebih baik, sekaligus mengurangi tingkat sinyal yang salah dalam situasi non-dominan. Dengan pengoptimalan parameter, dapat disesuaikan dengan karakteristik pasar dari berbagai periode dan varietas. Tetapi strategi ini lebih bergantung pada penyesuaian parameter daripada aplikasi mekanis.

Kode Sumber Strategi

/*backtest
start: 2022-10-06 00:00:00
end: 2023-10-12 00:00:00
period: 2d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Designed per No Nonsense Forex VP rules
//Made to be as modular as possible, so we can swap the indicators in and out.
//Originated from causecelebre
//Tried to put in as much VP rules as possible

///////////////////////////////////////////////////
//Rules Implemented:
///////////////////////////////////////////////////
// - SL 1.5 x ATR
// - TP 1 x ATR
//
// - Entry conditions
//// - Entry within first confirmation cross over and 1 candle of second confirmation + volume
// - Exit conditions
//// - Exit on exit indicator or when baseline or confirmation flip 

///////////////////////////////////////////////////
//Trades entries
///////////////////////////////////////////////////
// - First entry L1 or S1 with standard SL and TP

///////////////////////////////////////////////////
//Included Indicators and settings
///////////////////////////////////////////////////
// - Confirmtion = SSL 8, 16
// - Volume = TDFI 6

///////////////////////////////////////////////////
//Credits
// Strategy causecelebre https://www.tradingview.com/u/causecelebre/
// TDFI causecelebre https://www.tradingview.com/u/causecelebre/
// SSL Channel ErwinBeckers https://www.tradingview.com/u/ErwinBeckers/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// strategy(title="NNFX Strategy 3 Indicator Template | jh", overlay = true, pyramiding=0, initial_capital=20000, currency=currency.USD, calc_on_order_fills=0,default_qty_type=strategy.fixed, default_qty_value=10000)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  **** Set the main stuff  ****
///////////////////////////////////////////////////

//Price
price = close

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ATR stuff
///////////////////////////////////////////////////

slMultiplier = input(1.5, "SL")
tpMultiplier = input(1, "TP")

atrlength = input(title="ATR Length", defval=14, minval=1)
atrsmoothing = input(title="Smoothing", defval="SMA", options=["RMA", "SMA", "EMA", "WMA"])

ma_function(source, atrlength) => 
    if atrsmoothing == "RMA"
        rma(source, atrlength)
    else
        if atrsmoothing == "SMA"
            sma(source, atrlength)
        else
            if atrsmoothing == "EMA"
                ema(source, atrlength)
            else
                wma(source, atrlength)

//plot(ma_function(tr(true), atrlength), title = "ATR", color=#991515, transp=0)

atr = ma_function(tr(true), atrlength)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  **** Confirmation 1 Fast ****
///////////////////////////////////////////////////

///////////////////////////////////////////////////
//SSL 6
///////////////////////////////////////////////////

ssllen1=input(title="SSL 1 Length Period", defval=8)
smaHigh1=sma(high, ssllen1)
smaLow1=sma(low, ssllen1)
Hlv1 = na
Hlv1 := close > smaHigh1 ? 1 : close < smaLow1 ? -1 : Hlv1[1]
sslDown1 = Hlv1 < 0 ? smaHigh1: smaLow1
sslUp1   = Hlv1 < 0 ? smaLow1 : smaHigh1

plot(sslDown1, "SSL Down", linewidth=1, color=red)
plot(sslUp1, "SSL Up", linewidth=1, color=lime)

///////////////////////////////////////////////////
//Confirm Signals
///////////////////////////////////////////////////

c_Up = sslUp1
c_Down =sslDown1

//Signals based on crossover
c_cross_Long = crossover(c_Up, c_Down)
c_cross_Short = crossover(c_Down, c_Up)

//Signals based on signal position
c_trend_Long = c_Up > c_Down ? 1 : 0
c_trend_Short = c_Down > c_Up ? 1 : 0

confirm_Long = c_cross_Long
confirm_Short = c_cross_Short

plotshape(c_cross_Long, color = green, style=shape.triangleup, location=location.top)
plotshape(c_cross_Short, color = red, style=shape.triangledown, location=location.top)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  **** Confirmation 2 Slow ****
///////////////////////////////////////////////////

///////////////////////////////////////////////////
//SSL 30
///////////////////////////////////////////////////

///////////////////////////////////////////////////
//SSL
///////////////////////////////////////////////////

ssllen2=input(title="SSL 2 Length Period", defval=16)
smaHigh2=sma(high, ssllen2)
smaLow2=sma(low, ssllen2)
Hlv2 = na
Hlv2 := close > smaHigh2 ? 1 : close < smaLow2 ? -1 : Hlv2[1]
sslDown2 = Hlv2 < 0 ? smaHigh2: smaLow2
sslUp2   = Hlv2 < 0 ? smaLow2 : smaHigh2

plot(sslDown2, "SSL Down", linewidth=1, color=orange)
plot(sslUp2, "SSL Up", linewidth=1, color=blue)

///////////////////////////////////////////////////
//Confirm Signals
///////////////////////////////////////////////////
c2_Up = sslUp2
c2_Down = sslDown2

//Signals based on crossover
c2_cross_Long = crossover(c2_Up, c2_Down)
c2_cross_Short = crossover(c2_Down, c2_Up)

//Signals based on signal position
c2_trend_Long = c2_Up > c2_Down ? 1 : 0
c2_trend_Short = c2_Down > c2_Up ? 1 : 0

confirm2_Long = c2_trend_Long
confirm2_Short = c2_trend_Short

plotshape(c2_cross_Long, color = green, style=shape.triangleup, location=location.bottom)
plotshape(c2_cross_Short, color = red, style=shape.triangledown, location=location.bottom)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  **** Volume Indicator Start ****
///////////////////////////////////////////////////

///////////////////////////////////////////////////
//TDFI
///////////////////////////////////////////////////

lookback = input(6, title = "TDFI Lookback") 
filterHigh = input(0.05, title = "Filter High") 
filterLow = input(-0.05, title = "Filter Low") 

mma = ema(price * 1000, lookback)
smma = ema(mma, lookback)

impetmma = mma - mma[1]
impetsmma= smma - smma[1]
divma = abs(mma - smma)
averimpet = (impetmma + impetsmma) / 2

number = averimpet
pow = 3
result = na

for i = 1 to pow - 1
    if i == 1
        result := number
    result := result * number

tdf = divma * result
ntdf = tdf / highest(abs(tdf), lookback * 3)

///////////////////////////////////////////////////
//Volume Signals
///////////////////////////////////////////////////
v_Long = ntdf > filterHigh ? 1 : 0
v_Short = filterLow > ntdf ? 1 : 0

volumeLong = v_Long
volumeShort = v_Short

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **************************** Logic to handle NNFX rules ****************************
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Checking for confirmation indication with 1 candle difference for second confirmtion and volume
enterLong   = confirm_Long and (confirm2_Long[0] or confirm2_Long[1])      and (volumeLong[0] or volumeLong[1]) ? 1 : 0
enterShort  = confirm_Short and (confirm2_Short[0] or confirm2_Short[1])   and (volumeShort[0] or volumeShort[1]) ? 1 : 0

exitLong = c_cross_Short or c2_cross_Short ? 1 : 0 
exitShort = c_cross_Long or c2_cross_Long ? 1 : 0 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Entries and Exits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

if (year>2009)

    //Long entries with standard 1.5 ATR for SL, 1 ATR for TP
    long_sl = price - (atr * slMultiplier)
    long_tp = price + (atr * tpMultiplier)

    //Short entries with standard 1.5 ATR for SL, 1 ATR for TP
    short_sl = price + (atr * slMultiplier)
    short_tp = price - (atr * tpMultiplier)

    strategy.close("L1", when = exitLong)
    strategy.close("S1", when = exitShort)

    strategy.exit("L Limit Exit", "L1", stop = long_sl, limit = long_tp)
    strategy.exit("S Limit Exit", "S1", stop = short_sl, limit = short_tp)

    strategy.order("L1", strategy.long, when = enterLong)
    strategy.order("S1", strategy.short, when = enterShort)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//End
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Forums

PINE Language FAQ Summary MyLanguage Web3 About Us

Product

Robot Strategy Node Platforms Tickets

API

Syntax guide User guide Trading api Blockchain Indicator