Modulo Logik Dengan Strategi Penapis EMA

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

Ringkasan

Strategi ini menggabungkan operasi aritmatika modulo dan purata bergerak eksponensial untuk mewujudkan penapis rawak yang kuat untuk menentukan arah kedudukan. Ia mula-mula mengira baki harga dibahagikan dengan nombor yang ditetapkan, dan isyarat perdagangan dihasilkan jika baki adalah 0. Jika isyarat ini di bawah garis EMA, pergi pendek; jika di atas, pergi panjang. Strategi ini mengintegrasikan rawak operasi matematik dan trend penilaian penunjuk teknikal, menggunakan pengesahan silang antara penunjuk kitaran yang berbeza untuk menapis beberapa bunyi pasaran dengan berkesan.

Logika Strategi

Tetapkan nilai input harga a untuk menutup, boleh diubah suai; menetapkan pembahagi b kepada 4, boleh diubah suai.
Hitung modulo baki a dibahagikan dengan b, tentukan sama ada modulo sama dengan 0.
Tetapkan panjang EMA (MALen) kepada 70 tempoh secara lalai sebagai metrik untuk trend jangka sederhana hingga panjang.
Apabila modulo sama dengan 0, isyarat dagangan nombor genap dihasilkan. Digabungkan dengan hubungan EMA ia menentukan arah. Apabila harga melintasi EMA, isyarat BUY dihasilkan; apabila harga melintasi di bawah EMA, isyarat SELL dihasilkan.
Pendaftaran perdagangan dibuka panjang atau pendek berdasarkan arah isyarat. Strategi boleh menyekat kedudukan pembukaan terbalik untuk mengawal bilangan perdagangan.
Keadaan stop loss ditetapkan berdasarkan 3 pilihan: stop loss tetap, ATR stop loss, harga swing stop loss.
Hentian pengangkatan boleh diaktifkan untuk mengunci lebih banyak keuntungan, dilumpuhkan secara lalai.

Analisis Kelebihan

Keacakan aritmetik modulo mengelakkan kesan turun naik harga, digabungkan dengan penilaian trend purata bergerak, ia dapat menapis isyarat yang tidak sah dengan berkesan.
EMA sebagai metrik untuk trend jangka sederhana hingga panjang digabungkan dengan isyarat modulo jangka pendek merealisasikan pengesahan pelbagai lapisan dan mengelakkan isyarat palsu.
Parameter yang boleh disesuaikan sangat fleksibel, boleh diselaraskan untuk pasaran yang berbeza untuk mencari kombinasi parameter yang optimum.
Mengintegrasikan pelbagai kaedah stop loss untuk mengawal risiko.
Menyokong pembukaan pos secara langsung untuk menukar arah yang lancar.

Analisis Risiko

Tetapan parameter yang tidak betul boleh menghasilkan terlalu banyak isyarat dagangan, meningkatkan kekerapan dagangan dan kos slippage.
EMA sebagai satu-satunya metrik penilaian trend mungkin ketinggalan, kehilangan masa pembalikan harga.
Kaedah stop loss tetap boleh menjadi terlalu mekanikal, tidak dapat menyesuaikan diri dengan turun naik pasaran.
Pembukaan terbalik terus meningkatkan kekerapan penyesuaian kedudukan, menambah kos dan risiko.

Arahan pengoptimuman

Uji purata bergerak yang berbeza daripada EMA, atau gabungkan EMA dengan MA lain, untuk melihat sama ada kadar keuntungan dapat ditingkatkan.
Cuba menggabungkan penapis modulo dengan strategi lain seperti Bollinger Bands, corak candlestick dan lain-lain untuk membuat penapis yang lebih stabil.
Penyelidikan kaedah stop loss adaptif berdasarkan tahap turun naik pasaran untuk menyesuaikan jarak berhenti.
Tetapkan had jumlah dagangan atau ambang keuntungan / kerugian untuk mengehadkan kekerapan pembukaan terbalik langsung.

Kesimpulan

Strategi ini secara berkesan menggabungkan keacakan operasi modulo dan penilaian trend purata bergerak melalui penyesuaian parameter yang fleksibel yang memenuhi persekitaran pasaran yang berbeza, menghasilkan isyarat perdagangan yang boleh dipercayai. Ia juga mengintegrasikan pelbagai mekanisme berhenti untuk mengawal risiko serta mengambil keuntungan dan berhenti untuk mengunci keuntungan. Logik keseluruhan jelas dan mudah difahami dan diubah suai. Ia mempunyai potensi praktikal yang sangat besar yang bernilai pengujian dan pengoptimuman lanjut.

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

2019 FMZ - Semua hak dilindungi