Modulo Logic Dengan Strategi Filter EMA

Penulis:ChaoZhang, Tanggal: 2023-12-13 15:55:07
Tag:

Gambaran umum

Strategi ini menggabungkan operasi aritmatika modulo dan rata-rata bergerak eksponensial untuk menciptakan filter keacakan yang kuat untuk menentukan arah posisi. Pertama menghitung sisa harga dibagi dengan angka yang ditetapkan, dan sinyal perdagangan dihasilkan jika sisanya adalah 0. Jika sinyal ini berada di bawah garis EMA, pergi pendek; jika di atas, pergi panjang. Strategi ini mengintegrasikan keacakan operasi matematika dan tren penilaian indikator teknis, menggunakan validasi silang antara indikator dari siklus yang berbeda untuk secara efektif menyaring beberapa kebisingan pasar.

Logika Strategi

Atur nilai input harga a untuk menutup, dapat dimodifikasi; atur pembagi b menjadi 4, dapat dimodifikasi.
Hitung sisa modulo dari a dibagi dengan b, tentukan apakah modulo sama dengan 0.
Tetapkan panjang EMA (MALen) menjadi 70 periode secara default sebagai metrik untuk tren jangka menengah hingga panjang.
Ketika modulo sama dengan 0, sinyal perdagangan bilangan genap dihasilkan. Dikombinasikan dengan hubungan EMA, sinyal ini menentukan arah. Ketika harga melintasi EMA, sinyal BUY dihasilkan; ketika harga melintasi EMA, sinyal SELL dihasilkan.
Strategi dapat membatasi posisi pembukaan terbalik untuk mengontrol jumlah perdagangan.
Kondisi stop loss ditetapkan berdasarkan 3 opsi: stop loss tetap, ATR stop loss, harga swing stop loss.
Trailing stop dapat diaktifkan untuk mengunci lebih banyak keuntungan, dinonaktifkan secara default.

Analisis Keuntungan

Keacakan aritmatika modulo menghindari efek dari fluktuasi harga, dikombinasikan dengan penilaian tren dari moving average, dapat secara efektif menyaring sinyal yang tidak valid.
EMA sebagai metrik untuk tren jangka menengah hingga panjang dikombinasikan dengan sinyal modulo jangka pendek mewujudkan verifikasi multi-layer dan menghindari sinyal palsu.
Parameter yang dapat disesuaikan sangat fleksibel, dapat disesuaikan untuk pasar yang berbeda untuk menemukan kombinasi parameter optimal.
Mengintegrasikan beberapa metode stop loss untuk mengendalikan risiko.
Mendukung pembukaan posisi terbalik langsung untuk beralih arah yang mulus.

Analisis Risiko

Pengaturan parameter yang tidak benar dapat menghasilkan terlalu banyak sinyal perdagangan, meningkatkan frekuensi perdagangan dan biaya slippage.
EMA sebagai satu-satunya trend judgment metric mungkin tertinggal, kehilangan momen pembalikan harga.
Metode stop loss tetap bisa terlalu mekanis, tidak dapat disesuaikan dengan fluktuasi pasar.
Pembukaan terbalik langsung meningkatkan frekuensi penyesuaian posisi, menambah biaya dan risiko.

Arahan Optimasi

Uji rata-rata bergerak yang berbeda daripada EMA, atau gabungkan EMA dengan MAs lainnya, untuk melihat apakah tingkat profitabilitas dapat ditingkatkan.
Cobalah menggabungkan filter modulo dengan strategi lain seperti Bollinger Bands, pola candlestick dll untuk membuat filter yang lebih stabil.
Penelitian metode stop loss adaptif berdasarkan tingkat volatilitas pasar untuk menyesuaikan jarak stop.
Tetapkan batas jumlah perdagangan atau ambang keuntungan/kerugian untuk membatasi frekuensi pembukaan langsung.

Kesimpulan

Strategi ini secara efektif menggabungkan keacakan operasi modulo dan penilaian tren rata-rata bergerak melalui penyesuaian parameter yang fleksibel yang memenuhi lingkungan pasar yang berbeda, menghasilkan sinyal perdagangan yang dapat diandalkan. Ini juga mengintegrasikan berbagai mekanisme stop untuk mengendalikan risiko serta mengambil keuntungan dan trailing stop untuk mengunci keuntungan.

/*backtest
start: 2023-11-12 00:00:00
end: 2023-12-12 00:00:00
period: 1h
basePeriod: 15m
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/
// © tweakerID

// To understand this strategy first we need to look into the Modulo (%) operator. The modulo returns the remainder numerator 
// of a division's quotient (the result). If we do 5 / 3, we get 1 and 2/3 as a result, where the remainder is 2 (two thirds, in this case). This can be
// used for many things, for example to determine when a number divides evenly into another number. If we divide 3/3, our result is 1,
// with no remainder numerator, hence our modulo result is 0. In this strategy, we compare a given number (divisor, user defined) with the
// the closing price of every candle (dividend, modifiable from the inputs panel) to determine if the result between their division is an even number. 
// If the answer is true, we have an entry signal. If this signal occurs below the EMA (length is defined by the user) we go short and
// viceversa for longs. This logic can be reversed. In this case, the modulo works as a random-like filter for a moving average strategy
// that usually struggles when the market is ranging.

//@version=4

//@version=4
strategy("Modulo Logic + EMA Strat", 
     overlay=true, 
     default_qty_type=strategy.percent_of_equity, 
     default_qty_value=100, 
     initial_capital=10000, 
     commission_value=0.04, 
     calc_on_every_tick=false, 
     slippage=0)

direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))

/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")  

a=input(close, title="Dividend")
b=input(4, title="Divisor")
usemod=input(true, title="Use Modulo Logic")
MALen=input(70, title="EMA Length")

/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")  

// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=3, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(4, step=.1, title="ATR Multiple")
i_TPRRR = input(1, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(false, title="Trailing Stop")

// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1] 
 or strategy.position_size < strategy.position_size[1]

// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na 
entry_HH_price = strategy.position_size < 0 ? HH_price : na 
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR

// ATR Stop
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na 
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na 
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR


// Strategy Stop

float LongStop = na
float ShortStop = na
float StratTP = na
float StratSTP = na

/////////////////////// STRATEGY LOGIC /////////////////////////////////////////

modulo=a%b
evennumber=modulo==0
MA=ema(close, MALen)
plot(MA)

BUY=usemod ? evennumber and close > MA : close > MA
SELL=usemod ? evennumber and close < MA : close < MA

//Trading Inputs
DPR=input(true, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")

// Entries
if reverse
    if not DPR
        strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
    else     
        strategy.entry("long", strategy.long, when=SELL)
        strategy.entry("short", strategy.short, when=BUY)
else
    if not DPR 
        strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
    else
        strategy.entry("long", strategy.long, when=BUY)
        strategy.entry("short", strategy.short, when=SELL)


SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP

//TrailingStop
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
 -strategy.position_avg_price
trailOffset     = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
    tstop := high- trailOffset - dif
    if tstop<tstop[1]
        tstop:=tstop[1]
else
    tstop := na
StrailOffset     = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0 
 and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
    Ststop := low+ StrailOffset + Sdif
    if Ststop>Ststop[1]
        Ststop:=Ststop[1]
else
    Ststop := na

strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL, when=i_SL)

/////////////////////// PLOTS //////////////////////////////////////////////////

plot(i_SL and strategy.position_size > 0 and not TS ? SL : i_SL and strategy.position_size > 0 and TS ? tstop : na , title='SL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size < 0 and not TS ? SSL : i_SL and strategy.position_size < 0 and TS ? Ststop : na , title='SSL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(i_SL and strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar, 
 color=color.green, title="Bullish Setup", size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar, 
 color=color.red, title="Bearish Setup", size=size.auto)

Lebih banyak

2019 FMZ - Semua hak dilindungi