Mehrfaktorischem gleitendem Durchschnitt nach Strategie

Schriftsteller:ChaoZhang, Datum: 2024-01-18 12:07:52
Tags:

Übersicht

Dies ist eine einfache gleitende Durchschnitts-Trendstrategie, die für Bitcoin und Ethereum geeignet ist.

Strategie Logik

Die Kernlogik der Strategie besteht darin, lang zu gehen, wenn die 20-Tage-EMA über die 100-Tage-SMA und die 100-Tage-SMA über die 200-Tage-SMA kreuzt; schließen Positionen, wenn die 20-Tage-EMA unter die 100-Tage-SMA kreuzt. Das heißt, verwenden Sie drei gleitende Durchschnitte verschiedener Perioden, um die Trendrichtung zu bestimmen.

Insbesondere berechnet die Strategie die Werte der 20-Tage-EMA, der 100-Tage-SMA und der 200-Tage-SMA und vergleicht ihre Größenverhältnisse, um den Trend zu beurteilen. Wenn die 20-Tage-EMA über die 100-Tage-SMA geht, bedeutet dies, dass die Preise zu steigen begonnen haben. Wenn die 100-Tage-SMA auch größer ist als die 200-Tage-SMA, deutet dies darauf hin, dass die mittelfristigen und langfristigen Trends ebenfalls steigen. Dies ist ein starkes Langsignal.

Nach dem Eintritt in eine Long-Position hält die Strategie weiterhin die Position, um dem Trend zu folgen. Wenn der 20-tägige EMA erneut unter den 100-tägigen SMA fällt, zeigt dies an, dass ein kurzfristiges Trendumkehrsignal aufgetreten ist. Zu diesem Zeitpunkt wird die Strategie wählen, Positionen zu schließen, um Verluste zu stoppen.

Darüber hinaus beinhaltet die Strategie auch Indikatoren wie MACD und RSI, um den Trend zu bestätigen. Nur wenn die DIF-Linie, die DEMA-Linie und die HIST-Barlinie des MACD steigen und der RSI-Indikator über 50 liegt, wird es sich entscheiden, Long-Positionen zu eröffnen.

Vorteile

Der größte Vorteil dieser Strategie besteht darin, dass sie klare Trendhandelsregeln formuliert, die mittelfristige und langfristige Trends effektiv verfolgen können.

Verwenden Sie mehrere gleitende Durchschnitte kombiniert, um den Trend zu beurteilen, der relativ zuverlässig ist.
Annahme langfristiger Holdingpositionen, um Trendbewegungen zu verfolgen, ohne von kurzfristigen Marktschwankungen gestört zu werden.
Die Kombination von Indikatoren wie MACD und RSI zur Bestätigung von Strategiesignalen kann falsche Ausbrüche filtern.
Mit dem goldenen Kreuz und dem Todeskreuz der EMA- und SMA-Linien werden Ein- und Ausstiegspunkte bestimmt.
Kann Risiken effektiv kontrollieren, indem Verluste durch Stop Loss begrenzt werden.

Risiken und Lösungen

Es gibt auch einige Risiken für diese Strategie. Das Hauptproblem besteht darin, dass sie Verluste nicht rechtzeitig stoppen kann, wenn sich der Trend umkehrt.

Nicht in der Lage, Trendumkehrpunkte zeitlich zu verfolgen: Verkürzen Sie gleitende Durchschnittszyklen oder fügen Sie mehr Indikatoren für ein umfassendes Urteil hinzu.
Eine lange Haltedauer kann leicht zu größeren Verlusten führen: Verkürzen Sie die Exit-Linien richtig, um den Stop-Loss rechtzeitig zu erreichen.
Bewegliche Durchschnittsindikatoren neigen dazu, zu verzögern: Für den aktiven Stop-Loss wird ein bestimmter Prozentsatz von Stop-Loss-Linien hinzugefügt.

Optimierungsrichtlinien

Diese Strategie kann auch in folgenden Aspekten optimiert werden:

Testen Sie mehr Kombinationen von gleitenden Durchschnittszyklen, um die optimalen Parameter zu finden.
Versuchen Sie andere Indikatoren oder Modelle, um Trends und Eintrittszeiten zu beurteilen, wie Bollinger Bands, KD-Indikator usw.
Verwenden Sie maschinelles Lernen und andere Methoden, um Parameter dynamisch zu optimieren.
Einbeziehung von Handelsvolumenindikatoren, um falsche Ausbrüche zu vermeiden, z. B. auf Bilanzvolumen, Transaktionsvolumen usw.
Entwicklung automatischer Stop-Loss- und Stop-Loss-Tracking-Systeme, die Stop-Loss-Positionen anhand der Marktbedingungen anpassen können.

Schlussfolgerung

Zusammenfassend ist diese Strategie eine einfache und unkomplizierte Trendfolgestrategie. Sie verwendet gleitende Durchschnitte, um die Trendrichtung zu bestimmen, MACD und RSI, um Signale zu filtern. Es können relativ lange Halteperioden verwendet werden, um Trendbewegungen zu verfolgen.

/*backtest
start: 2024-01-16 00:00:00
end: 2024-01-17 00:00:00
period: 10m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy(title="BTC_Long_Only_TV01_200507", overlay=true)

//////////// !!!!!!!!!!!!!!!! WORK BEST IN 2 HOURS for BTC, ETH and ETHXBT !!!!!!!!!!!!!!!!!!! /////////////////////
//280820 - After long esting this is the best script for ETHUSD in 4 hours. From 01/01/2020 til 28/08/2020


[macdLine, macdSignalLine, macdHist] = macd(close, 12, 26, 7)  

//_rsi_len = input(14, title="RSI length")
_rsi_len = 14 
  
NewValue = 0
PreviousValue = 0
leverage = 1

smaPercentageIncrease = 0.0
SMA_PERCENT_INCREASE = 0.0
float atrValue = 0
bool bPositionOpened = false
float stockPositionSize = 0 
float volatilityPercentage = 0.0
bool bDisplayArrow = false 
bool bEMAIsRising = false
bool bSMAIsRising = false
bool bSMASlowIsRising = false
bool bMACDIsRising = false
bool bMACDHistIsRising = false
bool bMACDSignalIsRising = false

float stopLoss = input (5, "StopLoss in %", type=input.float) //StopLoss associated with the order
//Best for alt versus BTC float stopLoss = input (3, "StopLoss in %", type=input.float) //StopLoss associated with the order 
float positionSize = 1000
float currentPrice = close 
float stopLossPrice = 0
float entryPrice = 0


//-----------------------------------------------------------


// === INPUT BACKTEST RANGE ONE YEAR 
//FromDay   = input(defval = 01, title = "From Day", minval = 1, maxval = 31)
//FromMonth = input(defval = 01, title = "From Month", minval = 1, maxval = 12)
//FromYear  = input(defval = 2020, title = "From Year", minval = 2017)
FromDay   = 01
FromMonth = 01
FromYear  = 2020

//ToDay     = input(defval = 01, title = "To Day", minval = 1, maxval = 31)
//ToMonth   = input(defval = 01, title = "To Month", minval = 1, maxval = 12)
//ToYear    = input(defval = 2023, title = "To Year", minval = 2017)
ToDay     = 14
ToMonth   = 05
ToYear    = 2029

// === FUNCTION EXAMPLE ===
start     = timestamp(FromYear, FromMonth, FromDay, 00, 00)  // backtest start window
finish    = timestamp(ToYear, ToMonth, ToDay, 23, 59)        // backtest finish window
window()  => true // create function "within window of time"


//FUNCTION DEFINITIONS
//----------------------
IsRising(data, loopBack) =>
    bIsRising = true
    for n = 1 to loopBack
        if data[n] > data[n-1]
            bIsRising := false
        continue
    bIsRising
    
IsFalling(data, loopBack) =>
    bIsFalling = true
    for n = 1 to loopBack
        if data[n] < data[n-1]
            bIsFalling := false
        continue
    bIsFalling
    
// END OF FUNCTION DEFINITIONS //


emaLength = 20
smaLength = 100
smaSlowLength = 200
 
ema = ema(close, emaLength) 
sma = sma(close, smaLength)
smaSlow = sma(close, smaSlowLength)

plot(sma, color=color.green)
plot(smaSlow, color=color.orange)
plot(ema, color=color.yellow)

//reload previous values
stopLossPrice := na(stopLossPrice[1]) ? 0.0 : stopLossPrice[1]
entryPrice := na(entryPrice[1]) ? 0.0 : entryPrice[1]
bPositionOpened := na(bPositionOpened[1]) ? false : bPositionOpened[1]
positionSize := na(positionSize[1]) ? 1000 : positionSize[1]
stockPositionSize := na(stockPositionSize[1]) ? 0 : stockPositionSize[1]
//leverage := na(leverage[1]) ? 1 : leverage[1]

bEMAIsRising := IsRising(ema, 2) 
bSMAIsRising := IsRising(sma, 3)
bMACDIsRising := IsRising(macdLine, 3)
bMACDHistIsRising := IsRising(macdHist, 1)
bSMASlowIsRising := IsRising(smaSlow, 10)
bMACDSignalIsRising := IsRising(macdSignalLine, 3)


atrValue := atr(14)
volatilityPercentage := (atrValue/currentPrice)*100 //calcute the volatility. Percentage of the actual price

 
if (window()) 
    //Check if we can open a LONG
    if (bPositionOpened == false and bSMASlowIsRising == true and bMACDIsRising == true and bEMAIsRising == true and bSMAIsRising == true and ema[0] > sma[0] and sma[0] < currentPrice)
        //Enter in short position 
        stockPositionSize := (positionSize*leverage)/currentPrice //Calculate the position size based on the actual price and the position Size (in $) configured.
        
        //calculate exit values
        stopLossPrice := currentPrice*(1-stopLoss/100) 
        strategy.entry("myPosition", strategy.long, qty=stockPositionSize, comment="BUY at " + tostring(currentPrice))
        entryPrice := currentPrice //store the entry price
        bPositionOpened := true  
        bDisplayArrow := true 
        
    if (bPositionOpened == true and (currentPrice <= stopLossPrice or crossunder(ema[1], sma[1])))
        strategy.close("myPosition", comment="" + tostring(currentPrice) ) //Stop
        //uncomment the below line to make the bot investing the full portfolio amount to test compounding effect.
        //positionSize := positionSize + ((stockPositionSize * currentPrice) - (positionSize*leverage)) 
        //reset some flags 
        bPositionOpened := false 
        bDisplayArrow := true 
        entryPrice := 0.0

Mehr